-DOPENCV

# 1 "./src/maxpool_layer_kernels.cu"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "/usr/local/cuda/include/cuda_runtime.h" 1
# 56 "/usr/local/cuda/include/cuda_runtime.h"
#pragma GCC diagnostic push


#pragma GCC diagnostic ignored "-Wunused-function"
# 78 "/usr/local/cuda/include/cuda_runtime.h"
# 1 "/usr/local/cuda/include/host_config.h" 1
# 50 "/usr/local/cuda/include/host_config.h"
# 1 "/usr/local/cuda/include/crt/host_config.h" 1
# 179 "/usr/local/cuda/include/crt/host_config.h"
# 1 "/usr/include/features.h" 1 3 4
# 367 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 410 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 411 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 368 "/usr/include/features.h" 2 3 4
# 391 "/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
# 392 "/usr/include/features.h" 2 3 4
# 180 "/usr/local/cuda/include/crt/host_config.h" 2
# 50 "/usr/local/cuda/include/host_config.h" 2
# 79 "/usr/local/cuda/include/cuda_runtime.h" 2







# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 56 "/usr/local/cuda/include/builtin_types.h"
# 1 "/usr/local/cuda/include/device_types.h" 1
# 53 "/usr/local/cuda/include/device_types.h"
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 50 "/usr/local/cuda/include/host_defines.h"
# 1 "/usr/local/cuda/include/crt/host_defines.h" 1
# 50 "/usr/local/cuda/include/host_defines.h" 2
# 54 "/usr/local/cuda/include/device_types.h" 2







enum __attribute__((device_builtin)) cudaRoundMode
{
    cudaRoundNearest,
    cudaRoundZero,
    cudaRoundPosInf,
    cudaRoundMinInf
};
# 57 "/usr/local/cuda/include/builtin_types.h" 2


# 1 "/usr/local/cuda/include/driver_types.h" 1
# 53 "/usr/local/cuda/include/driver_types.h"
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 54 "/usr/local/cuda/include/driver_types.h" 2
# 1 "/usr/local/cuda/include/vector_types.h" 1
# 59 "/usr/local/cuda/include/vector_types.h"
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 60 "/usr/local/cuda/include/vector_types.h" 2
# 93 "/usr/local/cuda/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;
};
# 269 "/usr/local/cuda/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;
};
# 356 "/usr/local/cuda/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;







struct __attribute__((device_builtin)) dim3
{
    unsigned int x, y, z;

    __attribute__((host)) __attribute__((device)) dim3(unsigned int vx = 1, unsigned int vy = 1, unsigned int vz = 1) : x(vx), y(vy), z(vz) {}
    __attribute__((host)) __attribute__((device)) dim3(uint3 v) : x(v.x), y(v.y), z(v.z) {}
    __attribute__((host)) __attribute__((device)) operator uint3(void) { uint3 t; t.x = x; t.y = y; t.z = z; return t; }

};

typedef __attribute__((device_builtin)) struct dim3 dim3;
# 55 "/usr/local/cuda/include/driver_types.h" 2
# 72 "/usr/local/cuda/include/driver_types.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/limits.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/limits.h" 1 3 4
# 168 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 143 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
# 160 "/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
# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 144 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4
# 148 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
# 152 "/usr/include/limits.h" 2 3 4
# 169 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed/limits.h" 2 3 4
# 73 "/usr/local/cuda/include/driver_types.h" 2
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 149 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 3 4

# 149 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 216 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 74 "/usr/local/cuda/include/driver_types.h" 2
# 171 "/usr/local/cuda/include/driver_types.h"

# 171 "/usr/local/cuda/include/driver_types.h"
enum __attribute__((device_builtin)) cudaError
{





    cudaSuccess = 0,





    cudaErrorMissingConfiguration = 1,





    cudaErrorMemoryAllocation = 2,





    cudaErrorInitializationError = 3,
# 206 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchFailure = 4,
# 215 "/usr/local/cuda/include/driver_types.h"
    cudaErrorPriorLaunchFailure = 5,
# 226 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchTimeout = 6,
# 235 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchOutOfResources = 7,





    cudaErrorInvalidDeviceFunction = 8,
# 250 "/usr/local/cuda/include/driver_types.h"
    cudaErrorInvalidConfiguration = 9,





    cudaErrorInvalidDevice = 10,





    cudaErrorInvalidValue = 11,





    cudaErrorInvalidPitchValue = 12,





    cudaErrorInvalidSymbol = 13,




    cudaErrorMapBufferObjectFailed = 14,




    cudaErrorUnmapBufferObjectFailed = 15,





    cudaErrorInvalidHostPointer = 16,





    cudaErrorInvalidDevicePointer = 17,





    cudaErrorInvalidTexture = 18,





    cudaErrorInvalidTextureBinding = 19,






    cudaErrorInvalidChannelDescriptor = 20,





    cudaErrorInvalidMemcpyDirection = 21,
# 331 "/usr/local/cuda/include/driver_types.h"
    cudaErrorAddressOfConstant = 22,
# 340 "/usr/local/cuda/include/driver_types.h"
    cudaErrorTextureFetchFailed = 23,
# 349 "/usr/local/cuda/include/driver_types.h"
    cudaErrorTextureNotBound = 24,
# 358 "/usr/local/cuda/include/driver_types.h"
    cudaErrorSynchronizationError = 25,





    cudaErrorInvalidFilterSetting = 26,





    cudaErrorInvalidNormSetting = 27,







    cudaErrorMixedDeviceExecution = 28,






    cudaErrorCudartUnloading = 29,




    cudaErrorUnknown = 30,







    cudaErrorNotYetImplemented = 31,
# 407 "/usr/local/cuda/include/driver_types.h"
    cudaErrorMemoryValueTooLarge = 32,






    cudaErrorInvalidResourceHandle = 33,







    cudaErrorNotReady = 34,






    cudaErrorInsufficientDriver = 35,
# 442 "/usr/local/cuda/include/driver_types.h"
    cudaErrorSetOnActiveProcess = 36,





    cudaErrorInvalidSurface = 37,





    cudaErrorNoDevice = 38,





    cudaErrorECCUncorrectable = 39,




    cudaErrorSharedObjectSymbolNotFound = 40,




    cudaErrorSharedObjectInitFailed = 41,





    cudaErrorUnsupportedLimit = 42,





    cudaErrorDuplicateVariableName = 43,





    cudaErrorDuplicateTextureName = 44,





    cudaErrorDuplicateSurfaceName = 45,
# 504 "/usr/local/cuda/include/driver_types.h"
    cudaErrorDevicesUnavailable = 46,




    cudaErrorInvalidKernelImage = 47,







    cudaErrorNoKernelImageForDevice = 48,
# 530 "/usr/local/cuda/include/driver_types.h"
    cudaErrorIncompatibleDriverContext = 49,






    cudaErrorPeerAccessAlreadyEnabled = 50,






    cudaErrorPeerAccessNotEnabled = 51,





    cudaErrorDeviceAlreadyInUse = 54,






    cudaErrorProfilerDisabled = 55,







    cudaErrorProfilerNotInitialized = 56,






    cudaErrorProfilerAlreadyStarted = 57,






     cudaErrorProfilerAlreadyStopped = 58,







    cudaErrorAssert = 59,






    cudaErrorTooManyPeers = 60,





    cudaErrorHostMemoryAlreadyRegistered = 61,





    cudaErrorHostMemoryNotRegistered = 62,




    cudaErrorOperatingSystem = 63,





    cudaErrorPeerAccessUnsupported = 64,






    cudaErrorLaunchMaxDepthExceeded = 65,







    cudaErrorLaunchFileScopedTex = 66,







    cudaErrorLaunchFileScopedSurf = 67,
# 655 "/usr/local/cuda/include/driver_types.h"
    cudaErrorSyncDepthExceeded = 68,
# 667 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchPendingCountExceeded = 69,




    cudaErrorNotPermitted = 70,





    cudaErrorNotSupported = 71,
# 687 "/usr/local/cuda/include/driver_types.h"
    cudaErrorHardwareStackError = 72,







    cudaErrorIllegalInstruction = 73,
# 704 "/usr/local/cuda/include/driver_types.h"
    cudaErrorMisalignedAddress = 74,
# 715 "/usr/local/cuda/include/driver_types.h"
    cudaErrorInvalidAddressSpace = 75,







    cudaErrorInvalidPc = 76,







    cudaErrorIllegalAddress = 77,





    cudaErrorInvalidPtx = 78,




    cudaErrorInvalidGraphicsContext = 79,





    cudaErrorNvlinkUncorrectable = 80,






    cudaErrorJitCompilerNotFound = 81,
# 764 "/usr/local/cuda/include/driver_types.h"
    cudaErrorCooperativeLaunchTooLarge = 82,




    cudaErrorStartupFailure = 0x7f,







    cudaErrorApiFailureBase = 10000
};




enum __attribute__((device_builtin)) cudaChannelFormatKind
{
    cudaChannelFormatKindSigned = 0,
    cudaChannelFormatKindUnsigned = 1,
    cudaChannelFormatKindFloat = 2,
    cudaChannelFormatKindNone = 3
};




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;




enum __attribute__((device_builtin)) cudaMemoryType
{
    cudaMemoryTypeHost = 1,
    cudaMemoryTypeDevice = 2
};




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)) 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 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 memoryType;
# 1076 "/usr/local/cuda/include/driver_types.h"
    int device;





    void *devicePointer;





    void *hostPointer;




    int isManaged;
};




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;






   int preferredShmemCarveout;
};




enum __attribute__((device_builtin)) cudaFuncAttribute
{
    cudaFuncAttributeMaxDynamicSharedMemorySize = 8,
    cudaFuncAttributePreferredSharedMemoryCarveout = 9,
    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
};




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
};




enum __attribute__((device_builtin)) cudaOutputMode
{
    cudaKeyValuePair = 0x00,
    cudaCSV = 0x01
};




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
};





enum __attribute__((device_builtin)) cudaDeviceP2PAttr {
    cudaDevP2PAttrPerformanceRank = 1,
    cudaDevP2PAttrAccessSupported = 2,
    cudaDevP2PAttrNativeAtomicSupported = 3
};



struct __attribute__((device_builtin)) cudaDeviceProp
{
    char name[256];
    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 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;
};
# 1536 "/usr/local/cuda/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;
# 1558 "/usr/local/cuda/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 CUuuid_st cudaUUID_t;




typedef __attribute__((device_builtin)) enum cudaOutputMode cudaOutputMode_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;
};
# 60 "/usr/local/cuda/include/builtin_types.h" 2


# 1 "/usr/local/cuda/include/surface_types.h" 1
# 84 "/usr/local/cuda/include/surface_types.h"
enum __attribute__((device_builtin)) cudaSurfaceBoundaryMode
{
    cudaBoundaryModeZero = 0,
    cudaBoundaryModeClamp = 1,
    cudaBoundaryModeTrap = 2
};




enum __attribute__((device_builtin)) cudaSurfaceFormatMode
{
    cudaFormatModeForced = 0,
    cudaFormatModeAuto = 1
};




struct __attribute__((device_builtin)) surfaceReference
{



    struct cudaChannelFormatDesc channelDesc;
};




typedef __attribute__((device_builtin)) unsigned long long cudaSurfaceObject_t;
# 63 "/usr/local/cuda/include/builtin_types.h" 2
# 1 "/usr/local/cuda/include/texture_types.h" 1
# 84 "/usr/local/cuda/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)) textureReference
{



    int normalized;



    enum cudaTextureFilterMode filterMode;



    enum cudaTextureAddressMode addressMode[3];



    struct cudaChannelFormatDesc channelDesc;



    int sRGB;



    unsigned int maxAnisotropy;



    enum cudaTextureFilterMode mipmapFilterMode;



    float mipmapLevelBias;



    float minMipmapLevelClamp;



    float maxMipmapLevelClamp;
    int __cudaReserved[15];
};




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;
};




typedef __attribute__((device_builtin)) unsigned long long cudaTextureObject_t;
# 64 "/usr/local/cuda/include/builtin_types.h" 2
# 87 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/library_types.h" 1
# 54 "/usr/local/cuda/include/library_types.h"
typedef enum cudaDataType_t
{
 CUDA_R_16F= 2,
 CUDA_C_16F= 6,
 CUDA_R_32F= 0,
 CUDA_C_32F= 4,
 CUDA_R_64F= 1,
 CUDA_C_64F= 5,
 CUDA_R_8I = 3,
 CUDA_C_8I = 7,
 CUDA_R_8U = 8,
 CUDA_C_8U = 9,
 CUDA_R_32I= 10,
 CUDA_C_32I= 11,
 CUDA_R_32U= 12,
 CUDA_C_32U= 13
} cudaDataType;


typedef enum libraryPropertyType_t
{
 MAJOR_VERSION,
 MINOR_VERSION,
 PATCH_LEVEL
} libraryPropertyType;
# 88 "/usr/local/cuda/include/cuda_runtime.h" 2


# 1 "/usr/local/cuda/include/channel_descriptor.h" 1
# 62 "/usr/local/cuda/include/channel_descriptor.h"
# 1 "/usr/local/cuda/include/cuda_runtime_api.h" 1
# 133 "/usr/local/cuda/include/cuda_runtime_api.h"
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 134 "/usr/local/cuda/include/cuda_runtime_api.h" 2
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 135 "/usr/local/cuda/include/cuda_runtime_api.h" 2

# 1 "/usr/local/cuda/include/cuda_device_runtime_api.h" 1
# 119 "/usr/local/cuda/include/cuda_device_runtime_api.h"
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 120 "/usr/local/cuda/include/cuda_device_runtime_api.h" 2

extern "C"
{
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void);
extern __attribute__((device)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error);
extern __attribute__((device)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent_ptsz(cudaStream_t stream, cudaEvent_t event, unsigned int flags);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord_ptsz(cudaEvent_t event, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpyAsync_ptsz(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream);
extern __attribute__((device)) __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);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy2DAsync_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 cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync_ptsz(const struct cudaMemcpy3DParms *p, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync(void *devPtr, int value, size_t count, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemsetAsync_ptsz(void *devPtr, int value, size_t count, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync(void *devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset2DAsync_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 cudaMemset3DAsync(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMemset3DAsync_ptsz(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion);
# 178 "/usr/local/cuda/include/cuda_device_runtime_api.h"
extern __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBuffer(size_t alignment, size_t size);
# 206 "/usr/local/cuda/include/cuda_device_runtime_api.h"
extern __attribute__((device)) __attribute__((cudart_builtin)) void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice_ptsz(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2_ptsz(void *parameterBuffer, cudaStream_t stream);
# 226 "/usr/local/cuda/include/cuda_device_runtime_api.h"
    extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDevice(void *func, void *parameterBuffer, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize, cudaStream_t stream);
    extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaLaunchDeviceV2(void *parameterBuffer, cudaStream_t stream);


extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize);
extern __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *func, int blockSize, size_t dynamicSmemSize, unsigned int flags);

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 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);
}

template <typename T> static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(T **devPtr, size_t size);
template <typename T> static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, T *entry);
template <typename T> static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize);
template <typename T> static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, T func, int blockSize, size_t dynamicSmemSize, unsigned int flags);
# 137 "/usr/local/cuda/include/cuda_runtime_api.h" 2
# 218 "/usr/local/cuda/include/cuda_runtime_api.h"
extern "C" {
# 251 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceReset(void);
# 270 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void);
# 347 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceSetLimit(enum cudaLimit limit, size_t value);
# 378 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetLimit(size_t *pValue, enum cudaLimit limit);
# 410 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig);
# 446 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority);
# 489 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig);
# 519 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig);
# 562 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config);
# 587 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId);
# 615 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device);
# 660 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event);
# 698 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle);
# 739 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr);
# 792 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags);
# 825 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr);
# 865 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadExit(void);
# 889 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadSynchronize(void);
# 936 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value);
# 967 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit);
# 1002 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig);
# 1048 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig);
# 1104 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void);
# 1147 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void);
# 1163 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error);
# 1179 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error);
# 1210 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count);
# 1470 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device);
# 1647 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device);
# 1683 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetP2PAttribute(int *value, enum cudaDeviceP2PAttr attr, int srcDevice, int dstDevice);
# 1702 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop);
# 1737 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDevice(int device);
# 1755 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device);
# 1784 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len);
# 1847 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags );
# 1890 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags );
# 1928 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream);
# 1958 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags);
# 2002 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithPriority(cudaStream_t *pStream, unsigned int flags, int priority);
# 2027 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority);
# 2050 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags);
# 2079 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream);
# 2113 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags);
# 2127 "/usr/local/cuda/include/cuda_runtime_api.h"
typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData);
# 2185 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamAddCallback(cudaStream_t stream,
        cudaStreamCallback_t callback, void *userData, unsigned int flags);
# 2207 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream);
# 2230 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream);
# 2302 "/usr/local/cuda/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);
# 2339 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event);
# 2374 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags);
# 2406 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0);
# 2439 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event);
# 2472 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event);
# 2498 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event);
# 2540 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end);
# 2603 "/usr/local/cuda/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);
# 2658 "/usr/local/cuda/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);
# 2755 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaLaunchCooperativeKernelMultiDevice(struct cudaLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags = 0);
# 2804 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig);
# 2859 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config);
# 2894 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func);
# 2930 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncSetAttribute(const void *func, enum cudaFuncAttribute attr, int value);
# 2954 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d);
# 2978 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d);
# 3033 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *func, int blockSize, size_t dynamicSMemSize);
# 3077 "/usr/local/cuda/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);
# 3127 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem = 0, cudaStream_t stream = 0);
# 3156 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetupArgument(const void *arg, size_t size, size_t offset);
# 3197 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaLaunch(const void *func);
# 3316 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMallocManaged(void **devPtr, size_t size, unsigned int flags = 0x01);
# 3344 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size);
# 3375 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size);
# 3416 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMallocPitch(void **devPtr, size_t *pitch, size_t width, size_t height);
# 3460 "/usr/local/cuda/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);
# 3488 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr);
# 3510 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr);
# 3533 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array);
# 3556 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray);
# 3617 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags);
# 3698 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags);
# 3719 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr);
# 3762 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags);
# 3782 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost);
# 3819 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent);
# 3956 "/usr/local/cuda/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);
# 4093 "/usr/local/cuda/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);
# 4120 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level);
# 4223 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p);
# 4252 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p);
# 4368 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMemcpy3DAsync(const struct cudaMemcpy3DParms *p, cudaStream_t stream = 0);
# 4392 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0);
# 4413 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total);
# 4437 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaArrayGetInfo(struct cudaChannelFormatDesc *desc, struct cudaExtent *extent, unsigned int *flags, cudaArray_t array);
# 4478 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind);
# 4511 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpyPeer(void *dst, int dstDevice, const void *src, int srcDevice, size_t count);
# 4550 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind);
# 4588 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpyFromArray(void *dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind);
# 4627 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __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);
# 4673 "/usr/local/cuda/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);
# 4720 "/usr/local/cuda/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);
# 4767 "/usr/local/cuda/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);
# 4812 "/usr/local/cuda/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);
# 4853 "/usr/local/cuda/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);
# 4894 "/usr/local/cuda/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);
# 4948 "/usr/local/cuda/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);
# 4981 "/usr/local/cuda/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);
# 5028 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __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);
# 5074 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __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);
# 5134 "/usr/local/cuda/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);
# 5189 "/usr/local/cuda/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);
# 5243 "/usr/local/cuda/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);
# 5292 "/usr/local/cuda/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);
# 5341 "/usr/local/cuda/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);
# 5368 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count);
# 5400 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemset2D(void *devPtr, size_t pitch, int value, size_t width, size_t height);
# 5442 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent);
# 5476 "/usr/local/cuda/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);
# 5515 "/usr/local/cuda/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);
# 5564 "/usr/local/cuda/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);
# 5590 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol);
# 5615 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol);
# 5683 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemPrefetchAsync(const void *devPtr, size_t count, int dstDevice, cudaStream_t stream = 0);
# 5770 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemAdvise(const void *devPtr, size_t count, enum cudaMemoryAdvise advice, int device);
# 5827 "/usr/local/cuda/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);
# 5864 "/usr/local/cuda/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);
# 6018 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr);
# 6057 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice);
# 6097 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags);
# 6117 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice);
# 6178 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource);
# 6211 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags);
# 6248 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0);
# 6281 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0);
# 6311 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource);
# 6347 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t *array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel);
# 6374 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource);
# 6414 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array);
# 6450 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) struct cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f);
# 6501 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaBindTexture(size_t *offset, const struct textureReference *texref, const void *devPtr, const struct cudaChannelFormatDesc *desc, size_t size = 
# 6501 "/usr/local/cuda/include/cuda_runtime_api.h" 3 4
                                                                                                                                                                                      (0x7fffffff * 2U + 1U)
# 6501 "/usr/local/cuda/include/cuda_runtime_api.h"
                                                                                                                                                                                                    );
# 6556 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaBindTexture2D(size_t *offset, const struct textureReference *texref, const void *devPtr, const struct cudaChannelFormatDesc *desc, size_t width, size_t height, size_t pitch);
# 6590 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaBindTextureToArray(const struct textureReference *texref, cudaArray_const_t array, const struct cudaChannelFormatDesc *desc);
# 6626 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaBindTextureToMipmappedArray(const struct textureReference *texref, cudaMipmappedArray_const_t mipmappedArray, const struct cudaChannelFormatDesc *desc);
# 6647 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaUnbindTexture(const struct textureReference *texref);
# 6672 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureAlignmentOffset(size_t *offset, const struct textureReference *texref);
# 6698 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureReference(const struct textureReference **texref, const void *symbol);
# 6739 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaBindSurfaceToArray(const struct surfaceReference *surfref, cudaArray_const_t array, const struct cudaChannelFormatDesc *desc);
# 6760 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSurfaceReference(const struct surfaceReference **surfref, const void *symbol);
# 6988 "/usr/local/cuda/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);
# 7005 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject);
# 7023 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject);
# 7041 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject);
# 7060 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject);
# 7101 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc);
# 7118 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject);
# 7135 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject);
# 7164 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion);
# 7183 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaRuntimeGetVersion(int *runtimeVersion);




extern __attribute__((host)) cudaError_t cudaGetExportTable(const void **ppExportTable, const cudaUUID_t *pExportTableId);
# 7416 "/usr/local/cuda/include/cuda_runtime_api.h"
}
# 63 "/usr/local/cuda/include/channel_descriptor.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 64 "/usr/local/cuda/include/channel_descriptor.h" 2
# 107 "/usr/local/cuda/include/channel_descriptor.h"
template<class T> __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<char>(void)
{
  int e = (int)sizeof(char) * 8;




  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);

}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<signed char>(void)
{
  int e = (int)sizeof(signed char) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<unsigned char>(void)
{
  int e = (int)sizeof(unsigned char) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<char1>(void)
{
  int e = (int)sizeof(signed char) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<uchar1>(void)
{
  int e = (int)sizeof(unsigned char) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<char2>(void)
{
  int e = (int)sizeof(signed char) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<uchar2>(void)
{
  int e = (int)sizeof(unsigned char) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<char4>(void)
{
  int e = (int)sizeof(signed char) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<uchar4>(void)
{
  int e = (int)sizeof(unsigned char) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<short>(void)
{
  int e = (int)sizeof(short) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<unsigned short>(void)
{
  int e = (int)sizeof(unsigned short) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<short1>(void)
{
  int e = (int)sizeof(short) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<ushort1>(void)
{
  int e = (int)sizeof(unsigned short) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<short2>(void)
{
  int e = (int)sizeof(short) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<ushort2>(void)
{
  int e = (int)sizeof(unsigned short) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<short4>(void)
{
  int e = (int)sizeof(short) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<ushort4>(void)
{
  int e = (int)sizeof(unsigned short) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<int>(void)
{
  int e = (int)sizeof(int) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<unsigned int>(void)
{
  int e = (int)sizeof(unsigned int) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<int1>(void)
{
  int e = (int)sizeof(int) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<uint1>(void)
{
  int e = (int)sizeof(unsigned int) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<int2>(void)
{
  int e = (int)sizeof(int) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<uint2>(void)
{
  int e = (int)sizeof(unsigned int) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindUnsigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<int4>(void)
{
  int e = (int)sizeof(int) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindSigned);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<uint4>(void)
{
  int e = (int)sizeof(unsigned int) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindUnsigned);
}
# 379 "/usr/local/cuda/include/channel_descriptor.h"
template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<float>(void)
{
  int e = (int)sizeof(float) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<float1>(void)
{
  int e = (int)sizeof(float) * 8;

  return cudaCreateChannelDesc(e, 0, 0, 0, cudaChannelFormatKindFloat);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<float2>(void)
{
  int e = (int)sizeof(float) * 8;

  return cudaCreateChannelDesc(e, e, 0, 0, cudaChannelFormatKindFloat);
}

template<> __inline__ __attribute__((host)) cudaChannelFormatDesc cudaCreateChannelDesc<float4>(void)
{
  int e = (int)sizeof(float) * 8;

  return cudaCreateChannelDesc(e, e, e, e, cudaChannelFormatKindFloat);
}
# 91 "/usr/local/cuda/include/cuda_runtime.h" 2

# 1 "/usr/local/cuda/include/driver_functions.h" 1
# 53 "/usr/local/cuda/include/driver_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 54 "/usr/local/cuda/include/driver_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 55 "/usr/local/cuda/include/driver_functions.h" 2
# 79 "/usr/local/cuda/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/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/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;
}
# 93 "/usr/local/cuda/include/cuda_runtime.h" 2


# 1 "/usr/local/cuda/include/host_defines.h" 1
# 96 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/vector_functions.h" 1
# 59 "/usr/local/cuda/include/vector_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 60 "/usr/local/cuda/include/vector_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 61 "/usr/local/cuda/include/vector_functions.h" 2
# 75 "/usr/local/cuda/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/include/vector_functions.hpp" 1
# 59 "/usr/local/cuda/include/vector_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 60 "/usr/local/cuda/include/vector_functions.hpp" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 61 "/usr/local/cuda/include/vector_functions.hpp" 2
# 75 "/usr/local/cuda/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;
}
# 175 "/usr/local/cuda/include/vector_functions.h" 2
# 97 "/usr/local/cuda/include/cuda_runtime.h" 2
# 115 "/usr/local/cuda/include/cuda_runtime.h"
# 1 "/usr/local/cuda/include/common_functions.h" 1
# 50 "/usr/local/cuda/include/common_functions.h"
# 1 "/usr/local/cuda/include/crt/common_functions.h" 1
# 61 "/usr/local/cuda/include/crt/common_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 62 "/usr/local/cuda/include/crt/common_functions.h" 2
# 1 "/usr/local/cuda/include/crt/host_defines.h" 1
# 63 "/usr/local/cuda/include/crt/common_functions.h" 2




# 1 "/usr/include/string.h" 1 3 4
# 27 "/usr/include/string.h" 3 4

# 27 "/usr/include/string.h" 3 4
extern "C" {




# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 33 "/usr/include/string.h" 2 3 4









extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
       size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, const void *__src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
        int __c, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int memcmp (const void *__s1, const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 90 "/usr/include/string.h" 3 4
}










extern "C++" void *rawmemchr (void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));







extern "C++" void *memrchr (void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));









extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, const char *__restrict __src,
        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (const char *__s1, const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (2)));






# 1 "/usr/include/xlocale.h" 1 3 4
# 27 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{

  struct __locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;


typedef __locale_t locale_t;
# 160 "/usr/include/string.h" 2 3 4


extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));




extern char *strdup (const char *__s)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 206 "/usr/include/string.h" 3 4



extern "C++"
{
extern char *strchr (char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 229 "/usr/include/string.h" 3 4
}






extern "C++"
{
extern char *strrchr (char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 256 "/usr/include/string.h" 3 4
}










extern "C++" char *strchrnul (char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));









extern size_t strcspn (const char *__s, const char *__reject)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (const char *__s, const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 308 "/usr/include/string.h" 3 4
}






extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 335 "/usr/include/string.h" 3 4
}







extern char *strtok (char *__restrict __s, const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (2)));




extern char *__strtok_r (char *__restrict __s,
    const char *__restrict __delim,
    char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
         char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));





extern "C++" char *strcasestr (char *__haystack, const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
         const char *__needle)
     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 377 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
       const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
   const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern size_t strlen (const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strnlen (const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strerror (int __errnum) throw ();

# 433 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) ;





extern char *strerror_l (int __errnum, __locale_t __l) throw ();





extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));



extern void bcopy (const void *__src, void *__dest, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int bcmp (const void *__s1, const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern char *index (char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *index (const char *__s, int __c)
     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 482 "/usr/include/string.h" 3 4
}







extern "C++"
{
extern char *rindex (char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *rindex (const char *__s, int __c)
     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 510 "/usr/include/string.h" 3 4
}







extern int ffs (int __i) throw () __attribute__ ((__const__));




extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));



extern int strcasecmp (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));





extern int strcasecmp_l (const char *__s1, const char *__s2,
    __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (const char *__s1, const char *__s2,
     size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));





extern char *strsep (char **__restrict __stringp,
       const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (const char *__s1, const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));







extern "C++" char *basename (char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 658 "/usr/include/string.h" 3 4
}
# 68 "/usr/local/cuda/include/crt/common_functions.h" 2
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
extern "C" {







# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 38 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/time.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


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;







typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
# 121 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 122 "/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 int __daddr_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;


typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;


typedef long int __fsword_t;

typedef long int __ssize_t;


typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


typedef long int __intptr_t;


typedef unsigned int __socklen_t;
# 27 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4



struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 88 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4
struct timex
{
  unsigned int modes;
  __syscall_slong_t offset;
  __syscall_slong_t freq;
  __syscall_slong_t maxerror;
  __syscall_slong_t esterror;
  int status;
  __syscall_slong_t constant;
  __syscall_slong_t precision;
  __syscall_slong_t tolerance;
  struct timeval time;
  __syscall_slong_t tick;
  __syscall_slong_t ppsfreq;
  __syscall_slong_t jitter;
  int shift;
  __syscall_slong_t stabil;
  __syscall_slong_t jitcnt;
  __syscall_slong_t calcnt;
  __syscall_slong_t errcnt;
  __syscall_slong_t stbcnt;

  int tai;


  int :32; int :32; int :32; int :32;
  int :32; int :32; int :32; int :32;
  int :32; int :32; int :32;
};
# 89 "/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) throw ();

}
# 42 "/usr/include/time.h" 2 3 4
# 57 "/usr/include/time.h" 3 4


typedef __clock_t clock_t;



# 73 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 91 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 103 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 120 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    __syscall_slong_t tv_nsec;
  };








struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  const char *tm_zone;




};








struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };


struct sigevent;





typedef __pid_t pid_t;
# 186 "/usr/include/time.h" 3 4



extern clock_t clock (void) throw ();


extern time_t time (time_t *__timer) throw ();


extern double difftime (time_t __time1, time_t __time0)
     throw () __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) throw ();





extern size_t strftime (char *__restrict __s, size_t __maxsize,
   const char *__restrict __format,
   const struct tm *__restrict __tp) throw ();





extern char *strptime (const char *__restrict __s,
         const char *__restrict __fmt, struct tm *__tp)
     throw ();







extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
     const char *__restrict __format,
     const struct tm *__restrict __tp,
     __locale_t __loc) throw ();



extern char *strptime_l (const char *__restrict __s,
    const char *__restrict __fmt, struct tm *__tp,
    __locale_t __loc) throw ();






extern struct tm *gmtime (const time_t *__timer) throw ();



extern struct tm *localtime (const time_t *__timer) throw ();





extern struct tm *gmtime_r (const time_t *__restrict __timer,
       struct tm *__restrict __tp) throw ();



extern struct tm *localtime_r (const time_t *__restrict __timer,
          struct tm *__restrict __tp) throw ();





extern char *asctime (const struct tm *__tp) throw ();


extern char *ctime (const time_t *__timer) throw ();







extern char *asctime_r (const struct tm *__restrict __tp,
   char *__restrict __buf) throw ();


extern char *ctime_r (const time_t *__restrict __timer,
        char *__restrict __buf) throw ();




extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) throw ();



extern int daylight;
extern long int timezone;





extern int stime (const time_t *__when) throw ();
# 319 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();


extern time_t timelocal (struct tm *__tp) throw ();


extern int dysize (int __year) throw () __attribute__ ((__const__));
# 334 "/usr/include/time.h" 3 4
extern int nanosleep (const struct timespec *__requested_time,
        struct timespec *__remaining);



extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();


extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
     throw ();






extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       const struct timespec *__req,
       struct timespec *__rem);


extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();




extern int timer_create (clockid_t __clock_id,
    struct sigevent *__restrict __evp,
    timer_t *__restrict __timerid) throw ();


extern int timer_delete (timer_t __timerid) throw ();


extern int timer_settime (timer_t __timerid, int __flags,
     const struct itimerspec *__restrict __value,
     struct itimerspec *__restrict __ovalue) throw ();


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     throw ();


extern int timer_getoverrun (timer_t __timerid) throw ();





extern int timespec_get (struct timespec *__ts, int __base)
     throw () __attribute__ ((__nonnull__ (1)));
# 403 "/usr/include/time.h" 3 4
extern int getdate_err;
# 412 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 426 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
        struct tm *__restrict __resbufp);


}
# 69 "/usr/local/cuda/include/crt/common_functions.h" 2


# 70 "/usr/local/cuda/include/crt/common_functions.h"
extern "C"
{

extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void)




# 77 "/usr/local/cuda/include/crt/common_functions.h" 3 4
throw ()
# 77 "/usr/local/cuda/include/crt/common_functions.h"
      ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) 
# 78 "/usr/local/cuda/include/crt/common_functions.h" 3 4
                                                                                                                   throw ()
# 78 "/usr/local/cuda/include/crt/common_functions.h"
                                                                                                                          ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) 
# 79 "/usr/local/cuda/include/crt/common_functions.h" 3 4
                                                                                                                           throw ()
# 79 "/usr/local/cuda/include/crt/common_functions.h"
                                                                                                                                  ;

}
# 258 "/usr/local/cuda/include/crt/common_functions.h"
# 1 "/usr/local/cuda/include/crt/math_functions.h" 1
# 89 "/usr/local/cuda/include/crt/math_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 90 "/usr/local/cuda/include/crt/math_functions.h" 2
# 98 "/usr/local/cuda/include/crt/math_functions.h"
extern "C"
{
# 168 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int) 
# 168 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                      throw ()
# 168 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                             ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int) 
# 169 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                            throw ()
# 169 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                   ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int) 
# 170 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                  throw ()
# 170 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                         ;
# 220 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) 
# 220 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 220 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 261 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) 
# 261 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 261 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;



extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int min(int, int);

extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umin(unsigned int, unsigned int);
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmin(long long int, long long int);
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmin(unsigned long long int, unsigned long long int);
# 290 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) 
# 290 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 290 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 310 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) 
# 310 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                   throw ()
# 310 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                          ;






extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int max(int, int);

extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned int umax(unsigned int, unsigned int);
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llmax(long long int, long long int);
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) unsigned long long int ullmax(unsigned long long int, unsigned long long int);
# 342 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) 
# 342 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 342 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 362 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) 
# 362 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                               throw ()
# 362 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                      ;
# 406 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) 
# 406 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 406 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 439 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) 
# 439 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 439 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 458 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) 
# 458 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                       throw ()
# 458 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                              ;
# 474 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) 
# 474 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                     throw ()
# 474 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                            ;
# 519 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) 
# 519 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 519 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 588 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) 
# 588 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 588 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 660 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x);
# 730 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x);
# 786 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) 
# 786 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 786 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 811 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) 
# 811 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 811 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 836 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) 
# 836 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 836 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 863 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) 
# 863 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 863 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 886 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) 
# 886 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 886 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 932 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) 
# 932 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 932 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 977 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) 
# 977 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 977 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1032 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) 
# 1032 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 1032 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 1086 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) 
# 1086 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1086 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1157 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) 
# 1157 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 1157 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 1251 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) 
# 1251 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1251 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1348 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) 
# 1348 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1348 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1423 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) 
# 1423 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                     throw ()
# 1423 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                            ;
# 1462 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) 
# 1462 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 1462 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 1493 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) 
# 1493 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 1493 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 1523 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) 
# 1523 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 1523 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 1553 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) 
# 1553 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 1553 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 1588 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) 
# 1588 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1588 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1626 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) 
# 1626 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1626 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1642 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) 
# 1642 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1642 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1658 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) 
# 1658 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1658 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1712 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) 
# 1712 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1712 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1766 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) 
# 1766 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 1766 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 1825 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) 
# 1825 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                              throw ()
# 1825 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                     ;
# 1881 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) 
# 1881 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                   throw ()
# 1881 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                          ;
# 1933 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) 
# 1933 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 1933 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 1988 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) 
# 1988 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 1988 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 2018 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) 
# 2018 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2018 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2048 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) 
# 2048 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2048 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2124 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) 
# 2124 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 2124 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 2200 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) 
# 2200 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 2200 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 2276 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) 
# 2276 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                        throw ()
# 2276 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                               ;
# 2352 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) 
# 2352 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                        throw ()
# 2352 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                               ;
# 2430 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) 
# 2430 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                throw ()
# 2430 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                       ;
# 2505 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) 
# 2505 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                     throw ()
# 2505 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                            ;
# 2519 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) 
# 2519 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2519 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2536 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) 
# 2536 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2536 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2554 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) 
# 2554 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 2554 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 2572 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) 
# 2572 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 2572 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 2590 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) 
# 2590 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                            throw ()
# 2590 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                   ;
# 2608 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) 
# 2608 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                            throw ()
# 2608 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                   ;
# 2660 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) 
# 2660 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 2660 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 2676 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) 
# 2676 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2676 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2692 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) 
# 2692 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2692 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2708 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) 
# 2708 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 2708 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 2724 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) 
# 2724 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 2724 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 2777 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) 
# 2777 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                              throw ()
# 2777 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                     ;
# 2830 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) 
# 2830 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                              throw ()
# 2830 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                     ;
# 2892 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) 
# 2892 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                    throw ()
# 2892 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                           ;
# 2904 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) 
# 2904 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2904 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2919 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) 
# 2919 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 2919 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 2945 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) 
# 2945 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                   throw ()
# 2945 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                          ;
# 2971 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) 
# 2971 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 2971 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 3007 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) 
# 3007 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                    throw ()
# 3007 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                           ;
# 3038 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) 
# 3038 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 3038 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 3061 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) 
# 3061 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 3061 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 3093 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) 
# 3093 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 3093 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 3139 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) 
# 3139 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                              throw ()
# 3139 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                     ;
# 3191 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) 
# 3191 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                    throw ()
# 3191 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                           ;
# 3237 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) 
# 3237 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                            throw ()
# 3237 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                   ;
# 3289 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) 
# 3289 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                   throw ()
# 3289 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                          ;
# 3333 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) 
# 3333 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                          throw ()
# 3333 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                                 ;
# 3384 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) 
# 3384 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                               throw ()
# 3384 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                      ;
# 3433 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) 
# 3433 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                                    throw ()
# 3433 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                                           ;
# 3489 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm4d(double a, double b, double c, double d) 
# 3489 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                          throw ()
# 3489 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                 ;
# 3534 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm(int dim, double const * t) 
# 3534 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 3534 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 3585 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm(int dim, double const * t) 
# 3585 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 3585 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 3637 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnormf(int dim, float const * a) 
# 3637 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 3637 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 3681 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normf(int dim, float const * a) 
# 3681 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 3681 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 3726 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) 
# 3726 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                            throw ()
# 3726 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                   ;
# 3777 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) 
# 3777 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                             throw ()
# 3777 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                    ;
# 3826 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) 
# 3826 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                     throw ()
# 3826 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                            ;
# 3882 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnorm4df(float a, float b, float c, float d) 
# 3882 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                      throw ()
# 3882 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                             ;
# 3969 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) 
# 3969 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 3969 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 4055 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) 
# 4055 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 4055 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 4110 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x);
# 4160 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x);
# 4220 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x);
# 4280 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x);
# 4332 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x);
# 4384 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x);
# 4414 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr);
# 4444 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr);
# 4756 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) 
# 4756 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 4756 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 4812 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) 
# 4812 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                                  throw ()
# 4812 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                         ;
# 4871 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) 
# 4871 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                   throw ()
# 4871 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                          ;
# 4957 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) 
# 4957 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                        throw ()
# 4957 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                               ;
# 5047 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) 
# 5047 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                       throw ()
# 5047 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                              ;
# 5101 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) 
# 5101 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                               throw ()
# 5101 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                      ;
# 5155 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) 
# 5155 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                              throw ()
# 5155 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                     ;
# 5196 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) 
# 5196 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 5196 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 5238 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) 
# 5238 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                       throw ()
# 5238 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                              ;
# 5299 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) 
# 5299 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 5299 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 5360 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) 
# 5360 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                       throw ()
# 5360 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                              ;
# 5403 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) 
# 5403 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                         throw ()
# 5403 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                ;
# 5446 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) 
# 5446 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                              throw ()
# 5446 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                     ;
# 5498 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) 
# 5498 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 5498 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 5550 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) 
# 5550 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                       throw ()
# 5550 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                              ;
# 5602 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) 
# 5602 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 5602 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 5654 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) 
# 5654 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                       throw ()
# 5654 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                              ;
# 5707 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) 
# 5707 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                         throw ()
# 5707 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                ;
# 5760 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) 
# 5760 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                              throw ()
# 5760 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                     ;
# 5787 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) 
# 5787 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                             throw ()
# 5787 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                    ;
# 5813 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) 
# 5813 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 5813 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 5840 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) 
# 5840 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                             throw ()
# 5840 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                    ;
# 5866 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) 
# 5866 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 5866 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 5949 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) 
# 5949 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 5949 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 6031 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) 
# 6031 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 6031 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 6095 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double y);
# 6152 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float y);
# 6191 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) 
# 6191 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 6191 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 6229 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) 
# 6229 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 6229 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 6357 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) 
# 6357 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 6357 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 6420 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double y);
# 6476 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float y);
# 6534 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double y);
# 6592 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float y);
# 6635 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double y);
# 6678 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float y);
# 6753 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x);
# 6828 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x);
# 6962 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) 
# 6962 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 6962 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 7071 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) 
# 7071 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 7071 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 7180 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) 
# 7180 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 7180 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
# 7193 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) 
# 7193 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                       throw ()
# 7193 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                              ;
# 7206 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) 
# 7206 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                      throw ()
# 7206 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                             ;
# 7243 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) 
# 7243 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                        throw ()
# 7243 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                               ;
# 7280 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) 
# 7280 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                       throw ()
# 7280 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                              ;
# 7296 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) 
# 7296 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                throw ()
# 7296 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                       ;
# 7312 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) 
# 7312 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                 throw ()
# 7312 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                        ;






extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) 
# 7319 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 7319 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) 
# 7320 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 7320 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 7330 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finite(double) 
# 7330 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 7330 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitef(float) 
# 7331 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                           throw ()
# 7331 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                  ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbit(double) 
# 7332 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                            throw ()
# 7332 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                   ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(double) 
# 7333 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 7333 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(double) 
# 7334 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 7334 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;


extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) 
# 7337 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                            throw ()
# 7337 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                   ;
# 7496 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) 
# 7496 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                            throw ()
# 7496 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                   ;
# 7654 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) 
# 7654 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                          throw ()
# 7654 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                                 ;
# 7665 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) 
# 7665 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 7665 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;





extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __finitel(long double) 
# 7671 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                 throw ()
# 7671 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                        ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfl(long double) 
# 7672 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                throw ()
# 7672 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                       ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanl(long double) 
# 7673 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                throw ()
# 7673 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                       ;
# 7723 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) 
# 7723 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 7723 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 7763 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) 
# 7763 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 7763 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 7803 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) 
# 7803 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 7803 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 7836 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) 
# 7836 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                   throw ()
# 7836 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                          ;
# 7860 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) 
# 7860 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 7860 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 7902 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) 
# 7902 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 7902 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 7944 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) 
# 7944 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 7944 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 7968 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) 
# 7968 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 7968 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 8009 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) 
# 8009 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 8009 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 8039 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) 
# 8039 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 8039 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 8090 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) 
# 8090 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 8090 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 8140 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) 
# 8140 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                        throw ()
# 8140 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                               ;
# 8191 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) 
# 8191 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 8191 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 8246 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) 
# 8246 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                      throw ()
# 8246 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                             ;
# 8554 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) 
# 8554 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                 throw ()
# 8554 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                        ;
# 8623 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) 
# 8623 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 8623 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 8682 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) 
# 8682 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                         throw ()
# 8682 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                ;
# 8754 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) 
# 8754 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                          throw ()
# 8754 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                 ;
# 8813 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) 
# 8813 "/usr/local/cuda/include/crt/math_functions.h" 3 4
                                                                                                  throw ()
# 8813 "/usr/local/cuda/include/crt/math_functions.h"
                                                                                                         ;
# 8828 "/usr/local/cuda/include/crt/math_functions.h"
}


# 1 "/usr/include/math.h" 1 3 4
# 28 "/usr/include/math.h" 3 4

# 28 "/usr/include/math.h" 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
# 32 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/huge_val.h" 1 3 4
# 36 "/usr/include/math.h" 2 3 4

# 1 "/usr/include/x86_64-linux-gnu/bits/huge_valf.h" 1 3 4
# 38 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/huge_vall.h" 1 3 4
# 39 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/bits/inf.h" 1 3 4
# 42 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/bits/nan.h" 1 3 4
# 45 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/mathdef.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/mathdef.h" 3 4
typedef float float_t;
typedef double double_t;
# 49 "/usr/include/math.h" 2 3 4
# 83 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4


extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();


 extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

 extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();




extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();




 extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
                                                        ;





extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();







 extern double exp (double __x) throw (); extern double __exp (double __x) throw ();


extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();


extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();


 extern double log (double __x) throw (); extern double __log (double __x) throw ();


extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();


extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));




extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();

extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();





extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();


extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();


extern double logb (double __x) throw (); extern double __logb (double __x) throw ();






extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();


extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();








 extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();


extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();





extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();






extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();








extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));


extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));


extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));


extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();




extern int __isinf (double __value) throw () __attribute__ ((__const__));


extern int __finite (double __value) throw () __attribute__ ((__const__));








extern int isinf (double __value) throw () __attribute__ ((__const__));



extern int finite (double __value) throw () __attribute__ ((__const__));


extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();



extern double significand (double __x) throw (); extern double __significand (double __x) throw ();





extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));






extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnan (double __value) throw () __attribute__ ((__const__));






extern int isnan (double __value) throw () __attribute__ ((__const__));





extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();






extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();






extern double tgamma (double) throw (); extern double __tgamma (double) throw ();





extern double gamma (double) throw (); extern double __gamma (double) throw ();






extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();







extern double rint (double __x) throw (); extern double __rint (double __x) throw ();


extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));



extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();



extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();



extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();




extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();



extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();



extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));



extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();






extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();



extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();



extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();


extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));


extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));



extern int __fpclassify (double __value) throw ()
     __attribute__ ((__const__));


extern int __signbit (double __value) throw ()
     __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();








extern int __issignaling (double __value) throw ()
     __attribute__ ((__const__));






extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 84 "/usr/include/math.h" 2 3 4
# 104 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4


extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();


 extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

 extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();




extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();




 extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
                                                        ;





extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();







 extern float expf (float __x) throw (); extern float __expf (float __x) throw ();


extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();


extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();


 extern float logf (float __x) throw (); extern float __logf (float __x) throw ();


extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();


extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));




extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();

extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();





extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();


extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();


extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();






extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();


extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();








 extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();


extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();





extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();






extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();








extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));


extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));


extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));


extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();




extern int __isinff (float __value) throw () __attribute__ ((__const__));


extern int __finitef (float __value) throw () __attribute__ ((__const__));








extern int isinff (float __value) throw () __attribute__ ((__const__));



extern int finitef (float __value) throw () __attribute__ ((__const__));


extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();



extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();





extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));






extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanf (float __value) throw () __attribute__ ((__const__));






extern int isnanf (float __value) throw () __attribute__ ((__const__));





extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();






extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();






extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();





extern float gammaf (float) throw (); extern float __gammaf (float) throw ();






extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();







extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();


extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));



extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();



extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();



extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();




extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();



extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();



extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));



extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();






extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();



extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();



extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();


extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));


extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));



extern int __fpclassifyf (float __value) throw ()
     __attribute__ ((__const__));


extern int __signbitf (float __value) throw ()
     __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();








extern int __issignalingf (float __value) throw ()
     __attribute__ ((__const__));






extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 105 "/usr/include/math.h" 2 3 4
# 151 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4


extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();


 extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

 extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();




extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();




 extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ()
                                                        ;





extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();







 extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();


extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();


extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();


 extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();


extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();


extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));




extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();

extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();





extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();


extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();


extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();






extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();


extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();








 extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();


extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();





extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();






extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();








extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));


extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));


extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();




extern int __isinfl (long double __value) throw () __attribute__ ((__const__));


extern int __finitel (long double __value) throw () __attribute__ ((__const__));








extern int isinfl (long double __value) throw () __attribute__ ((__const__));



extern int finitel (long double __value) throw () __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();



extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();





extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));






extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanl (long double __value) throw () __attribute__ ((__const__));






extern int isnanl (long double __value) throw () __attribute__ ((__const__));





extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();






extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();






extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();





extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();






extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();







extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();


extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));



extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();



extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();



extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();




extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();



extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();



extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));



extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();






extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();



extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();



extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();


extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));


extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));



extern int __fpclassifyl (long double __value) throw ()
     __attribute__ ((__const__));


extern int __signbitl (long double __value) throw ()
     __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();








extern int __issignalingl (long double __value) throw ()
     __attribute__ ((__const__));






extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 152 "/usr/include/math.h" 2 3 4
# 168 "/usr/include/math.h" 3 4
extern int signgam;
# 209 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

      4
  };
# 347 "/usr/include/math.h" 3 4
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 370 "/usr/include/math.h" 3 4
struct __exception



  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };


extern int matherr (struct __exception *__exc) throw ();
# 534 "/usr/include/math.h" 3 4
}
# 8832 "/usr/local/cuda/include/crt/math_functions.h" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 32 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/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
# 50 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
  P_ALL,
  P_PID,
  P_PGID
} idtype_t;
# 42 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 64 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 36 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 2 3 4
# 60 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4






# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap-16.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4
# 44 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline unsigned int
__bswap_32 (unsigned int __bsx)
{
  return __builtin_bswap32 (__bsx);
}
# 108 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
  return __builtin_bswap64 (__bsx);
}
# 61 "/usr/include/endian.h" 2 3 4
# 65 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 2 3 4

union wait
  {
    int w_status;
    struct
      {

 unsigned int __w_termsig:7;
 unsigned int __w_coredump:1;
 unsigned int __w_retcode:8;
 unsigned int:16;







      } __wait_terminated;
    struct
      {

 unsigned int __w_stopval:8;
 unsigned int __w_stopsig:8;
 unsigned int:16;






      } __wait_stopped;
  };
# 43 "/usr/include/stdlib.h" 2 3 4
# 95 "/usr/include/stdlib.h" 3 4


typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;







__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;


# 139 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;




extern double atof (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern int atoi (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern long int atol (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;





__extension__ extern long long int atoll (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;





extern double strtod (const char *__restrict __nptr,
        char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));





extern float strtof (const char *__restrict __nptr,
       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));

extern long double strtold (const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));





extern long int strtol (const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoq (const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));





__extension__
extern long long int strtoll (const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

# 239 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

extern double strtod_l (const char *__restrict __nptr,
   char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
         char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));
# 305 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () ;


extern long int a64l (const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;




# 1 "/usr/include/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;
# 104 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 136 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 147 "/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;
# 194 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 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
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4



typedef __sigset_t sigset_t;







# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
# 46 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 54 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef long int __fd_mask;
# 64 "/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;
# 96 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern "C" {
# 106 "/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);
# 118 "/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);
# 131 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
}
# 220 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4


# 1 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
extern "C" {

__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
     throw () __attribute__ ((__const__));
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw () __attribute__ ((__const__));
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
            unsigned int __minor)
     throw () __attribute__ ((__const__));
# 58 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
}
# 223 "/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;
# 262 "/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
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.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.h" 2 3 4
# 60 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;


union pthread_attr_t
{
  char __size[56];
  long int __align;
};

typedef union pthread_attr_t pthread_attr_t;





typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;
# 90 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
typedef union
{
  struct __pthread_mutex_s
  {
    int __lock;
    unsigned int __count;
    int __owner;

    unsigned int __nusers;



    int __kind;

    short __spins;
    short __elision;
    __pthread_list_t __list;
# 125 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
  } __data;
  char __size[40];
  long int __align;
} pthread_mutex_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_mutexattr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __futex;
    __extension__ unsigned long long int __total_seq;
    __extension__ unsigned long long int __wakeup_seq;
    __extension__ unsigned long long int __woken_seq;
    void *__mutex;
    unsigned int __nwaiters;
    unsigned int __broadcast_seq;
  } __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;





typedef union
{

  struct
  {
    int __lock;
    unsigned int __nr_readers;
    unsigned int __readers_wakeup;
    unsigned int __writer_wakeup;
    unsigned int __nr_readers_queued;
    unsigned int __nr_writers_queued;
    int __writer;
    int __shared;
    signed char __rwelision;




    unsigned char __pad1[7];


    unsigned long int __pad2;


    unsigned int __flags;

  } __data;
# 220 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
  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;
# 271 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4


}
# 315 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) throw ();


extern void srandom (unsigned int __seed) throw ();





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     throw () __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();




extern int rand_r (unsigned int *__seed) throw ();







extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    __extension__ unsigned long long int __a;

  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (1, 2)));









extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;

extern void *calloc (size_t __nmemb, size_t __size)
     throw () __attribute__ ((__malloc__)) ;










extern void *realloc (void *__ptr, size_t __size)
     throw () __attribute__ ((__warn_unused_result__));

extern void free (void *__ptr) throw ();




extern void cfree (void *__ptr) throw ();



# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) throw ();





}
# 493 "/usr/include/stdlib.h" 2 3 4





extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__nonnull__ (1))) ;




extern void *aligned_alloc (size_t __alignment, size_t __size)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;




extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));




extern "C++" int at_quick_exit (void (*__func) (void))
     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));









extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     throw () __attribute__ ((__nonnull__ (1)));






extern void exit (int __status) throw () __attribute__ ((__noreturn__));





extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));







extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));






extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;





extern char *secure_getenv (const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) ;






extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));





extern int setenv (const char *__name, const char *__value, int __replace)
     throw () __attribute__ ((__nonnull__ (2)));


extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));






extern int clearenv (void) throw ();
# 606 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 619 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 629 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 641 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 651 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) ;
# 662 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 673 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 683 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 693 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 705 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;









extern int system (const char *__command) ;






extern char *canonicalize_file_name (const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 733 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
         char *__restrict __resolved) throw () ;






typedef int (*__compar_fn_t) (const void *, const void *);


typedef __compar_fn_t comparison_fn_t;



typedef int (*__compar_d_fn_t) (const void *, const void *, void *);





extern void *bsearch (const void *__key, const void *__base,
        size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5))) ;







extern void qsort (void *__base, size_t __nmemb, size_t __size,
     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));

extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
       __compar_d_fn_t __compar, void *__arg)
  __attribute__ ((__nonnull__ (1, 4)));




extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;



__extension__ extern long long int llabs (long long int __x)
     throw () __attribute__ ((__const__)) ;







extern div_t div (int __numer, int __denom)
     throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
     throw () __attribute__ ((__const__)) ;




__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     throw () __attribute__ ((__const__)) ;

# 811 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;




extern char *gcvt (double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) ;




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) ;




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));






extern int mblen (const char *__s, size_t __n) throw ();


extern int mbtowc (wchar_t *__restrict __pwc,
     const char *__restrict __s, size_t __n) throw ();


extern int wctomb (char *__s, wchar_t __wchar) throw ();



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
   const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
   const wchar_t *__restrict __pwcs, size_t __n)
     throw ();








extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 898 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *const *__restrict __tokens,
        char **__restrict __valuep)
     throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;





extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));







extern int posix_openpt (int __oflag) ;







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw () ;






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     throw () __attribute__ ((__nonnull__ (1)));


# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 955 "/usr/include/stdlib.h" 2 3 4
# 967 "/usr/include/stdlib.h" 3 4
}
# 8833 "/usr/local/cuda/include/crt/math_functions.h" 2


# 1 "/usr/include/c++/5/cmath" 1 3
# 39 "/usr/include/c++/5/cmath" 3
       
# 40 "/usr/include/c++/5/cmath" 3

# 1 "/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h" 1 3
# 194 "/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h" 3
namespace std
{
  typedef long unsigned int size_t;
  typedef long int ptrdiff_t;




}
# 216 "/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h" 3
namespace std
{
  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
# 482 "/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h" 3
# 1 "/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h" 1 3
# 483 "/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h" 2 3


# 1 "/usr/include/x86_64-linux-gnu/c++/5/bits/cpu_defines.h" 1 3
# 486 "/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h" 2 3
# 42 "/usr/include/c++/5/cmath" 2 3
# 1 "/usr/include/c++/5/bits/cpp_type_traits.h" 1 3
# 35 "/usr/include/c++/5/bits/cpp_type_traits.h" 3
       
# 36 "/usr/include/c++/5/bits/cpp_type_traits.h" 3
# 68 "/usr/include/c++/5/bits/cpp_type_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


  template<typename _Iterator, typename _Container>
    class __normal_iterator;


}

namespace std __attribute__ ((__visibility__ ("default")))
{


  struct __true_type { };
  struct __false_type { };

  template<bool>
    struct __truth_type
    { typedef __false_type __type; };

  template<>
    struct __truth_type<true>
    { typedef __true_type __type; };



  template<class _Sp, class _Tp>
    struct __traitor
    {
      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
      typedef typename __truth_type<__value>::__type __type;
    };


  template<typename, typename>
    struct __are_same
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Tp>
    struct __are_same<_Tp, _Tp>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<typename _Tp>
    struct __is_void
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_void<void>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_integer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };





  template<>
    struct __is_integer<bool>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<>
    struct __is_integer<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 199 "/usr/include/c++/5/bits/cpp_type_traits.h" 3
  template<>
    struct __is_integer<short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 270 "/usr/include/c++/5/bits/cpp_type_traits.h" 3
template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type; };
# 287 "/usr/include/c++/5/bits/cpp_type_traits.h" 3
  template<typename _Tp>
    struct __is_floating
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };


  template<>
    struct __is_floating<float>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_floating<double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_floating<long double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_pointer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Tp>
    struct __is_pointer<_Tp*>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_normal_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Iterator, typename _Container>
    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
             _Container> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_arithmetic
    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
    { };




  template<typename _Tp>
    struct __is_scalar
    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
    { };




  template<typename _Tp>
    struct __is_char
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_char<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<>
    struct __is_char<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<typename _Tp>
    struct __is_byte
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_byte<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_byte<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_byte<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_move_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };
# 443 "/usr/include/c++/5/bits/cpp_type_traits.h" 3

}
# 43 "/usr/include/c++/5/cmath" 2 3
# 1 "/usr/include/c++/5/ext/type_traits.h" 1 3
# 32 "/usr/include/c++/5/ext/type_traits.h" 3
       
# 33 "/usr/include/c++/5/ext/type_traits.h" 3




namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  template<bool, typename>
    struct __enable_if
    { };

  template<typename _Tp>
    struct __enable_if<true, _Tp>
    { typedef _Tp __type; };



  template<bool _Cond, typename _Iftrue, typename _Iffalse>
    struct __conditional_type
    { typedef _Iftrue __type; };

  template<typename _Iftrue, typename _Iffalse>
    struct __conditional_type<false, _Iftrue, _Iffalse>
    { typedef _Iffalse __type; };



  template<typename _Tp>
    struct __add_unsigned
    {
    private:
      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

    public:
      typedef typename __if_type::__type __type;
    };

  template<>
    struct __add_unsigned<char>
    { typedef unsigned char __type; };

  template<>
    struct __add_unsigned<signed char>
    { typedef unsigned char __type; };

  template<>
    struct __add_unsigned<short>
    { typedef unsigned short __type; };

  template<>
    struct __add_unsigned<int>
    { typedef unsigned int __type; };

  template<>
    struct __add_unsigned<long>
    { typedef unsigned long __type; };

  template<>
    struct __add_unsigned<long long>
    { typedef unsigned long long __type; };


  template<>
    struct __add_unsigned<bool>;

  template<>
    struct __add_unsigned<wchar_t>;



  template<typename _Tp>
    struct __remove_unsigned
    {
    private:
      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

    public:
      typedef typename __if_type::__type __type;
    };

  template<>
    struct __remove_unsigned<char>
    { typedef signed char __type; };

  template<>
    struct __remove_unsigned<unsigned char>
    { typedef signed char __type; };

  template<>
    struct __remove_unsigned<unsigned short>
    { typedef short __type; };

  template<>
    struct __remove_unsigned<unsigned int>
    { typedef int __type; };

  template<>
    struct __remove_unsigned<unsigned long>
    { typedef long __type; };

  template<>
    struct __remove_unsigned<unsigned long long>
    { typedef long long __type; };


  template<>
    struct __remove_unsigned<bool>;

  template<>
    struct __remove_unsigned<wchar_t>;



  template<typename _Type>
    inline bool
    __is_null_pointer(_Type* __ptr)
    { return __ptr == 0; }

  template<typename _Type>
    inline bool
    __is_null_pointer(_Type)
    { return false; }
# 165 "/usr/include/c++/5/ext/type_traits.h" 3
  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
    struct __promote
    { typedef double __type; };




  template<typename _Tp>
    struct __promote<_Tp, false>
    { };

  template<>
    struct __promote<long double>
    { typedef long double __type; };

  template<>
    struct __promote<double>
    { typedef double __type; };

  template<>
    struct __promote<float>
    { typedef float __type; };

  template<typename _Tp, typename _Up,
           typename _Tp2 = typename __promote<_Tp>::__type,
           typename _Up2 = typename __promote<_Up>::__type>
    struct __promote_2
    {
      typedef __typeof__(_Tp2() + _Up2()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp,
           typename _Tp2 = typename __promote<_Tp>::__type,
           typename _Up2 = typename __promote<_Up>::__type,
           typename _Vp2 = typename __promote<_Vp>::__type>
    struct __promote_3
    {
      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
    };

  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
           typename _Tp2 = typename __promote<_Tp>::__type,
           typename _Up2 = typename __promote<_Up>::__type,
           typename _Vp2 = typename __promote<_Vp>::__type,
           typename _Wp2 = typename __promote<_Wp>::__type>
    struct __promote_4
    {
      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
    };


}
# 44 "/usr/include/c++/5/cmath" 2 3
# 75 "/usr/include/c++/5/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  inline double
  abs(double __x)
  { return __builtin_fabs(__x); }



  inline float
  abs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  abs(long double __x)
  { return __builtin_fabsl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    abs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::acos;


  inline float
  acos(float __x)
  { return __builtin_acosf(__x); }

  inline long double
  acos(long double __x)
  { return __builtin_acosl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;


  inline float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline long double
  asin(long double __x)
  { return __builtin_asinl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;


  inline float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline long double
  atan(long double __x)
  { return __builtin_atanl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;


  inline float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }


  template<typename _Tp, typename _Up>
    inline
    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 float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;


  inline float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline long double
  cos(long double __x)
  { return __builtin_cosl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;


  inline float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;


  inline float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline long double
  exp(long double __x)
  { return __builtin_expl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;


  inline float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    fabs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::floor;


  inline float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline long double
  floor(long double __x)
  { return __builtin_floorl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;


  inline float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }


  template<typename _Tp, typename _Up>
    inline
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmod(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmod(__type(__x), __type(__y));
    }

  using ::frexp;


  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;


  inline float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ldexp(_Tp __x, int __exp)
    { return __builtin_ldexp(__x, __exp); }

  using ::log;


  inline float
  log(float __x)
  { return __builtin_logf(__x); }

  inline long double
  log(long double __x)
  { return __builtin_logl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;


  inline float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline long double
  log10(long double __x)
  { return __builtin_log10l(__x); }


  template<typename _Tp>
    inline
    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 float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }




  inline double
  pow(double __x, int __i)
  { return __builtin_powi(__x, __i); }

  inline float
  pow(float __x, int __n)
  { return __builtin_powif(__x, __n); }

  inline long double
  pow(long double __x, int __n)
  { return __builtin_powil(__x, __n); }



  template<typename _Tp, typename _Up>
    inline
    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 float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline long double
  sin(long double __x)
  { return __builtin_sinl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;


  inline float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;


  inline float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;


  inline float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline long double
  tan(long double __x)
  { return __builtin_tanl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;


  inline float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }


  template<typename _Tp>
    inline
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }


}
# 555 "/usr/include/c++/5/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 831 "/usr/include/c++/5/cmath" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    fpclassify(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_fpclassify(0, 1, 4,
      3, 2, __type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isfinite(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isfinite(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isinf(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isinf(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isnan(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isnan(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isnormal(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isnormal(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    signbit(_Tp __f)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return sizeof(__type) == sizeof(float)
 ? __builtin_signbitf(__type(__f))
 : sizeof(__type) == sizeof(double)
 ? __builtin_signbit(__type(__f))
 : __builtin_signbitl(__type(__f));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isgreater(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isgreater(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isgreaterequal(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isless(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isless(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    islessequal(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_islessequal(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    islessgreater(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_islessgreater(__type(__f1), __type(__f2));
    }

  template<typename _Tp>
    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
        int>::__type
    isunordered(_Tp __f1, _Tp __f2)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __builtin_isunordered(__type(__f1), __type(__f2));
    }




}
# 8836 "/usr/local/cuda/include/crt/math_functions.h" 2
# 1 "/usr/include/c++/5/cstdlib" 1 3
# 39 "/usr/include/c++/5/cstdlib" 3
       
# 40 "/usr/include/c++/5/cstdlib" 3
# 114 "/usr/include/c++/5/cstdlib" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::div_t;
  using ::ldiv_t;

  using ::abort;
  using ::abs;
  using ::atexit;





  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 ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;



  inline long
  abs(long __i) { return __builtin_labs(__i); }

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }



  inline long long
  abs(long long __x) { return __builtin_llabs (__x); }



  inline __int128
  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 195 "/usr/include/c++/5/cstdlib" 3

}
# 209 "/usr/include/c++/5/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;
# 241 "/usr/include/c++/5/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;
}
# 8837 "/usr/local/cuda/include/crt/math_functions.h" 2
# 8942 "/usr/local/cuda/include/crt/math_functions.h"

# 8942 "/usr/local/cuda/include/crt/math_functions.h"
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(float x);



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(double x);

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(long double x);

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(float x);



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(double x);

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(long double x);

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(float x);



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(double x) throw();

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(long double x);

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(float x);



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(double x) throw();

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(long double x);
# 9029 "/usr/local/cuda/include/crt/math_functions.h"
namespace std
{
  template<typename T> extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) T __pow_helper(T, int);
  template<typename T> 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;
# 9424 "/usr/local/cuda/include/crt/math_functions.h"
namespace std {
# 9433 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int);
# 9443 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int);
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);
# 9459 "/usr/local/cuda/include/crt/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, int);
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double pow(double, int);




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);
# 9555 "/usr/local/cuda/include/crt/math_functions.h"
}
# 9698 "/usr/local/cuda/include/crt/math_functions.h"
static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float logb(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int ilogb(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float scalbn(float a, int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float scalbln(float a, long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp2(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float expm1(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log2(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log1p(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acosh(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asinh(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atanh(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float hypot(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float norm3d(float a, float b, float c);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float norm4d(float a, float b, float c, float d);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cbrt(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erf(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfc(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float lgamma(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tgamma(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float copysign(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float nextafter(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remainder(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float remquo(float a, float b, int *quo);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float round(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int lround(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int llround(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float trunc(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rint(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int lrint(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int llrint(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float nearbyint(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fdim(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fma(float a, float b, float c);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmax(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmin(float a, float b);
# 9807 "/usr/local/cuda/include/crt/math_functions.h"
static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp10(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rsqrt(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float rcbrt(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinpi(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cospi(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincospi(float a, float *sptr, float *cptr);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void sincos(float a, float *sptr, float *cptr);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j0(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float j1(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float jn(int n, float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y0(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float y1(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float yn(int n, float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i0(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cyl_bessel_i1(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfinv(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcinv(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdfinv(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float normcdf(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float erfcx(float a);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(double a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double copysign(float a, double b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(unsigned int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int min(unsigned int a, int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int min(long int a, long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(unsigned long int a, unsigned long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(long int a, unsigned long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int min(unsigned long int a, long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int min(long long int a, long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(unsigned long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int min(unsigned long long int a, long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float min(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(double a, double b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(float a, double b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double min(double a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(unsigned int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned int max(unsigned int a, int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int max(long int a, long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(unsigned long int a, unsigned long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(long int a, unsigned long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long int max(unsigned long int a, long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int max(long long int a, long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(unsigned long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int max(unsigned long long int a, long long int b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float max(float a, float b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(double a, double b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(float a, double b);

static inline __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double max(double a, float b);
# 10198 "/usr/local/cuda/include/crt/math_functions.h"
# 1 "/usr/local/cuda/include/crt/math_functions.hpp" 1
# 67 "/usr/local/cuda/include/crt/math_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/crt/math_functions.hpp" 2
# 281 "/usr/local/cuda/include/crt/math_functions.hpp"
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(float x) { return __signbitf(x); }



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(double x) { return __signbit(x); }

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(long double x) { return __signbitl(x);}
# 298 "/usr/local/cuda/include/crt/math_functions.hpp"
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(float x) { return __finitef(x); }
# 313 "/usr/local/cuda/include/crt/math_functions.hpp"
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(double x) { return __finite(x); }
# 326 "/usr/local/cuda/include/crt/math_functions.hpp"
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(long double x) { return __finitel(x); }


__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(float x) { return __isnanf(x); }



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(double x) throw() { return __isnan(x); }

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(long double x) { return __isnanl(x); }

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(float x) { return __isinff(x); }



__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(double x) throw() { return __isinf(x); }

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(long double x) { return __isinfl(x); }
# 549 "/usr/local/cuda/include/crt/math_functions.hpp"
static inline __attribute__((host)) __attribute__((device)) float logb(float a)
{
  return logbf(a);
}

static inline __attribute__((host)) __attribute__((device)) int ilogb(float a)
{
  return ilogbf(a);
}

static inline __attribute__((host)) __attribute__((device)) float scalbn(float a, int b)
{
  return scalbnf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float scalbln(float a, long int b)
{
  return scalblnf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float exp2(float a)
{
  return exp2f(a);
}

static inline __attribute__((host)) __attribute__((device)) float expm1(float a)
{
  return expm1f(a);
}

static inline __attribute__((host)) __attribute__((device)) float log2(float a)
{
  return log2f(a);
}

static inline __attribute__((host)) __attribute__((device)) float log1p(float a)
{
  return log1pf(a);
}

static inline __attribute__((host)) __attribute__((device)) float acosh(float a)
{
  return acoshf(a);
}

static inline __attribute__((host)) __attribute__((device)) float asinh(float a)
{
  return asinhf(a);
}

static inline __attribute__((host)) __attribute__((device)) float atanh(float a)
{
  return atanhf(a);
}

static inline __attribute__((host)) __attribute__((device)) float hypot(float a, float b)
{
  return hypotf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float norm3d(float a, float b, float c)
{
  return norm3df(a, b, c);
}

static inline __attribute__((host)) __attribute__((device)) float norm4d(float a, float b, float c, float d)
{
  return norm4df(a, b, c, d);
}

static inline __attribute__((host)) __attribute__((device)) float cbrt(float a)
{
  return cbrtf(a);
}

static inline __attribute__((host)) __attribute__((device)) float erf(float a)
{
  return erff(a);
}

static inline __attribute__((host)) __attribute__((device)) float erfc(float a)
{
  return erfcf(a);
}

static inline __attribute__((host)) __attribute__((device)) float lgamma(float a)
{
  return lgammaf(a);
}

static inline __attribute__((host)) __attribute__((device)) float tgamma(float a)
{
  return tgammaf(a);
}

static inline __attribute__((host)) __attribute__((device)) float copysign(float a, float b)
{
  return copysignf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float nextafter(float a, float b)
{
  return nextafterf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float remainder(float a, float b)
{
  return remainderf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float remquo(float a, float b, int *quo)
{
  return remquof(a, b, quo);
}

static inline __attribute__((host)) __attribute__((device)) float round(float a)
{
  return roundf(a);
}

static inline __attribute__((host)) __attribute__((device)) long int lround(float a)
{
  return lroundf(a);
}

static inline __attribute__((host)) __attribute__((device)) long long int llround(float a)
{
  return llroundf(a);
}

static inline __attribute__((host)) __attribute__((device)) float trunc(float a)
{
  return truncf(a);
}

static inline __attribute__((host)) __attribute__((device)) float rint(float a)
{
  return rintf(a);
}

static inline __attribute__((host)) __attribute__((device)) long int lrint(float a)
{
  return lrintf(a);
}

static inline __attribute__((host)) __attribute__((device)) long long int llrint(float a)
{
  return llrintf(a);
}

static inline __attribute__((host)) __attribute__((device)) float nearbyint(float a)
{
  return nearbyintf(a);
}

static inline __attribute__((host)) __attribute__((device)) float fdim(float a, float b)
{
  return fdimf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float fma(float a, float b, float c)
{
  return fmaf(a, b, c);
}

static inline __attribute__((host)) __attribute__((device)) float fmax(float a, float b)
{
  return fmaxf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) float fmin(float a, float b)
{
  return fminf(a, b);
}







static inline __attribute__((host)) __attribute__((device)) float exp10(float a)
{
  return exp10f(a);
}

static inline __attribute__((host)) __attribute__((device)) float rsqrt(float a)
{
  return rsqrtf(a);
}

static inline __attribute__((host)) __attribute__((device)) float rcbrt(float a)
{
  return rcbrtf(a);
}

static inline __attribute__((host)) __attribute__((device)) float sinpi(float a)
{
  return sinpif(a);
}

static inline __attribute__((host)) __attribute__((device)) float cospi(float a)
{
  return cospif(a);
}

static inline __attribute__((host)) __attribute__((device)) void sincospi(float a, float *sptr, float *cptr)
{
  sincospif(a, sptr, cptr);
}

static inline __attribute__((host)) __attribute__((device)) void sincos(float a, float *sptr, float *cptr)
{
  sincosf(a, sptr, cptr);
}

static inline __attribute__((host)) __attribute__((device)) float j0(float a)
{
  return j0f(a);
}

static inline __attribute__((host)) __attribute__((device)) float j1(float a)
{
  return j1f(a);
}

static inline __attribute__((host)) __attribute__((device)) float jn(int n, float a)
{
  return jnf(n, a);
}

static inline __attribute__((host)) __attribute__((device)) float y0(float a)
{
  return y0f(a);
}

static inline __attribute__((host)) __attribute__((device)) float y1(float a)
{
  return y1f(a);
}

static inline __attribute__((host)) __attribute__((device)) float yn(int n, float a)
{
  return ynf(n, a);
}

static inline __attribute__((host)) __attribute__((device)) float cyl_bessel_i0(float a)
{
  return cyl_bessel_i0f(a);
}

static inline __attribute__((host)) __attribute__((device)) float cyl_bessel_i1(float a)
{
  return cyl_bessel_i1f(a);
}

static inline __attribute__((host)) __attribute__((device)) float erfinv(float a)
{
  return erfinvf(a);
}

static inline __attribute__((host)) __attribute__((device)) float erfcinv(float a)
{
  return erfcinvf(a);
}

static inline __attribute__((host)) __attribute__((device)) float normcdfinv(float a)
{
  return normcdfinvf(a);
}

static inline __attribute__((host)) __attribute__((device)) float normcdf(float a)
{
  return normcdff(a);
}

static inline __attribute__((host)) __attribute__((device)) float erfcx(float a)
{
  return erfcxf(a);
}

static inline __attribute__((host)) __attribute__((device)) double copysign(double a, float b)
{
  return copysign(a, (double)b);
}

static inline __attribute__((host)) __attribute__((device)) double copysign(float a, double b)
{
  return copysign((double)a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned int min(unsigned int a, unsigned int b)
{
  return umin(a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned int min(int a, unsigned int b)
{
  return umin((unsigned int)a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned int min(unsigned int a, int b)
{
  return umin(a, (unsigned int)b);
}

static inline __attribute__((host)) __attribute__((device)) long int min(long int a, long int b)
{





  if (sizeof(long int) == sizeof(int)) {



    return (long int)min((int)a, (int)b);
  } else {
    return (long int)llmin((long long int)a, (long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) unsigned long int min(unsigned long int a, unsigned long int b)
{



  if (sizeof(unsigned long int) == sizeof(unsigned int)) {



    return (unsigned long int)umin((unsigned int)a, (unsigned int)b);
  } else {
    return (unsigned long int)ullmin((unsigned long long int)a, (unsigned long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) unsigned long int min(long int a, unsigned long int b)
{



  if (sizeof(unsigned long int) == sizeof(unsigned int)) {



    return (unsigned long int)umin((unsigned int)a, (unsigned int)b);
  } else {
    return (unsigned long int)ullmin((unsigned long long int)a, (unsigned long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) unsigned long int min(unsigned long int a, long int b)
{



  if (sizeof(unsigned long int) == sizeof(unsigned int)) {



    return (unsigned long int)umin((unsigned int)a, (unsigned int)b);
  } else {
    return (unsigned long int)ullmin((unsigned long long int)a, (unsigned long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) long long int min(long long int a, long long int b)
{
  return llmin(a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(unsigned long long int a, unsigned long long int b)
{
  return ullmin(a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(long long int a, unsigned long long int b)
{
  return ullmin((unsigned long long int)a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(unsigned long long int a, long long int b)
{
  return ullmin(a, (unsigned long long int)b);
}

static inline __attribute__((host)) __attribute__((device)) float min(float a, float b)
{
  return fminf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) double min(double a, double b)
{
  return fmin(a, b);
}

static inline __attribute__((host)) __attribute__((device)) double min(float a, double b)
{
  return fmin((double)a, b);
}

static inline __attribute__((host)) __attribute__((device)) double min(double a, float b)
{
  return fmin(a, (double)b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned int max(unsigned int a, unsigned int b)
{
  return umax(a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned int max(int a, unsigned int b)
{
  return umax((unsigned int)a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned int max(unsigned int a, int b)
{
  return umax(a, (unsigned int)b);
}

static inline __attribute__((host)) __attribute__((device)) long int max(long int a, long int b)
{




  if (sizeof(long int) == sizeof(int)) {



    return (long int)max((int)a, (int)b);
  } else {
    return (long int)llmax((long long int)a, (long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) unsigned long int max(unsigned long int a, unsigned long int b)
{



  if (sizeof(unsigned long int) == sizeof(unsigned int)) {



    return (unsigned long int)umax((unsigned int)a, (unsigned int)b);
  } else {
    return (unsigned long int)ullmax((unsigned long long int)a, (unsigned long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) unsigned long int max(long int a, unsigned long int b)
{



  if (sizeof(unsigned long int) == sizeof(unsigned int)) {



    return (unsigned long int)umax((unsigned int)a, (unsigned int)b);
  } else {
    return (unsigned long int)ullmax((unsigned long long int)a, (unsigned long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) unsigned long int max(unsigned long int a, long int b)
{



  if (sizeof(unsigned long int) == sizeof(unsigned int)) {



    return (unsigned long int)umax((unsigned int)a, (unsigned int)b);
  } else {
    return (unsigned long int)ullmax((unsigned long long int)a, (unsigned long long int)b);
  }
}

static inline __attribute__((host)) __attribute__((device)) long long int max(long long int a, long long int b)
{
  return llmax(a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(unsigned long long int a, unsigned long long int b)
{
  return ullmax(a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(long long int a, unsigned long long int b)
{
  return ullmax((unsigned long long int)a, b);
}

static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(unsigned long long int a, long long int b)
{
  return ullmax(a, (unsigned long long int)b);
}

static inline __attribute__((host)) __attribute__((device)) float max(float a, float b)
{
  return fmaxf(a, b);
}

static inline __attribute__((host)) __attribute__((device)) double max(double a, double b)
{
  return fmax(a, b);
}

static inline __attribute__((host)) __attribute__((device)) double max(float a, double b)
{
  return fmax((double)a, b);
}

static inline __attribute__((host)) __attribute__((device)) double max(double a, float b)
{
  return fmax(a, (double)b);
}
# 1082 "/usr/local/cuda/include/crt/math_functions.hpp"
inline __attribute__((host)) __attribute__((device)) int min(int a, int b)
{
  return a < b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) unsigned umin(unsigned int a, unsigned int b)
{
  return a < b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) long long int llmin(long long int a, long long int b)
{
  return a < b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmin(unsigned long long int a,
                                              unsigned long long int b)
{
  return a < b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) int max(int a, int b)
{
  return a > b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) unsigned int umax(unsigned int a, unsigned int b)
{
  return a > b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) long long int llmax(long long int a, long long int b)
{
  return a > b ? a : b;
}

inline __attribute__((host)) __attribute__((device)) unsigned long long int ullmax(unsigned long long int a,
                                                    unsigned long long int b)
{
  return a > b ? a : b;
}
# 10199 "/usr/local/cuda/include/crt/math_functions.h" 2
# 259 "/usr/local/cuda/include/crt/common_functions.h" 2
# 50 "/usr/local/cuda/include/common_functions.h" 2
# 116 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/cuda_surface_types.h" 1
# 61 "/usr/local/cuda/include/cuda_surface_types.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 62 "/usr/local/cuda/include/cuda_surface_types.h" 2






# 1 "/usr/local/cuda/include/host_defines.h" 1
# 69 "/usr/local/cuda/include/cuda_surface_types.h" 2
# 77 "/usr/local/cuda/include/cuda_surface_types.h"
template<class T, int dim = 1>
struct __attribute__((device_builtin_surface_type)) surface : public surfaceReference
{

  __attribute__((host)) surface(void)
  {
    channelDesc = cudaCreateChannelDesc<T>();
  }

  __attribute__((host)) surface(struct cudaChannelFormatDesc desc)
  {
    channelDesc = desc;
  }

};

template<int dim>
struct __attribute__((device_builtin_surface_type)) surface<void, dim> : public surfaceReference
{

  __attribute__((host)) surface(void)
  {
    channelDesc = cudaCreateChannelDesc<void>();
  }

};
# 117 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/cuda_texture_types.h" 1
# 61 "/usr/local/cuda/include/cuda_texture_types.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 62 "/usr/local/cuda/include/cuda_texture_types.h" 2






# 1 "/usr/local/cuda/include/host_defines.h" 1
# 69 "/usr/local/cuda/include/cuda_texture_types.h" 2
# 77 "/usr/local/cuda/include/cuda_texture_types.h"
template<class T, int texType = 0x01, enum cudaTextureReadMode mode = cudaReadModeElementType>
struct __attribute__((device_builtin_texture_type)) texture : public textureReference
{

  __attribute__((host)) texture(int norm = 0,
                   enum cudaTextureFilterMode fMode = cudaFilterModePoint,
                   enum cudaTextureAddressMode aMode = cudaAddressModeClamp)
  {
    normalized = norm;
    filterMode = fMode;
    addressMode[0] = aMode;
    addressMode[1] = aMode;
    addressMode[2] = aMode;
    channelDesc = cudaCreateChannelDesc<T>();
    sRGB = 0;
  }

  __attribute__((host)) texture(int norm,
                   enum cudaTextureFilterMode fMode,
                   enum cudaTextureAddressMode aMode,
                   struct cudaChannelFormatDesc desc)
  {
    normalized = norm;
    filterMode = fMode;
    addressMode[0] = aMode;
    addressMode[1] = aMode;
    addressMode[2] = aMode;
    channelDesc = desc;
    sRGB = 0;
  }

};
# 118 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/device_functions.h" 1
# 50 "/usr/local/cuda/include/device_functions.h"
# 1 "/usr/local/cuda/include/crt/device_functions.h" 1
# 69 "/usr/local/cuda/include/crt/device_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/device_types.h" 1
# 71 "/usr/local/cuda/include/crt/device_functions.h" 2
# 79 "/usr/local/cuda/include/crt/device_functions.h"
extern "C"
{
# 90 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mulhi(int x, int y);
# 100 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y);
# 110 "/usr/local/cuda/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);
# 120 "/usr/local/cuda/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);
# 129 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int_as_float(int x);
# 138 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float_as_int(float x);
# 147 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint_as_float(unsigned int x);
# 156 "/usr/local/cuda/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__((device_builtin)) void __trap(void);
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) void __brkpt(int c = 0);
# 185 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __saturatef(float x);
# 254 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z);
# 322 "/usr/local/cuda/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);
# 332 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __mul24(int x, int y);
# 342 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y);
# 355 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float fdividef(float x, float y);
# 430 "/usr/local/cuda/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);
# 443 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) 
# 443 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                      throw ()
# 443 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                             ;
# 455 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) 
# 455 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                      throw ()
# 455 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                             ;
# 469 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) 
# 469 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                      throw ()
# 469 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                             ;
# 484 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) 
# 484 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                                                   throw ()
# 484 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                                                          ;
# 534 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) 
# 534 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                      throw ()
# 534 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                             ;
# 566 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) 
# 566 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                        throw ()
# 566 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                               ;
# 592 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) 
# 592 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                       throw ()
# 592 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                              ;
# 620 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) 
# 620 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                        throw ()
# 620 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                               ;
# 664 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) 
# 664 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                      throw ()
# 664 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                             ;
# 707 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) 
# 707 "/usr/local/cuda/include/crt/device_functions.h" 3 4
                                                                                                               throw ()
# 707 "/usr/local/cuda/include/crt/device_functions.h"
                                                                                                                      ;
# 716 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rn(float x);
# 725 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rz(float x);
# 734 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_ru(float);
# 743 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __float2int_rd(float x);
# 752 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x);
# 761 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x);
# 770 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x);
# 779 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x);
# 788 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rn(int x);
# 797 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rz(int x);
# 806 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_ru(int x);
# 815 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __int2float_rd(int x);
# 824 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x);
# 833 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x);
# 842 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x);
# 851 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x);
# 860 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rn(float x);
# 869 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rz(float x);
# 878 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_ru(float x);
# 887 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __float2ll_rd(float x);
# 896 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x);
# 905 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x);
# 914 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x);
# 923 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x);
# 932 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rn(long long int x);
# 941 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rz(long long int x);
# 950 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_ru(long long int x);
# 959 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ll2float_rd(long long int x);
# 968 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x);
# 977 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x);
# 986 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x);
# 995 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x);
# 1007 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rn(float x, float y);
# 1019 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rz(float x, float y);
# 1031 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_ru(float x, float y);
# 1043 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fadd_rd(float x, float y);
# 1055 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rn(float x, float y);
# 1067 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rz(float x, float y);
# 1079 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_ru(float x, float y);
# 1091 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsub_rd(float x, float y);
# 1103 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rn(float x, float y);
# 1115 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rz(float x, float y);
# 1127 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_ru(float x, float y);
# 1139 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmul_rd(float x, float y);
# 1292 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z);
# 1445 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z);
# 1598 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z);
# 1751 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z);
# 1784 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rn(float x);
# 1817 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rz(float x);
# 1850 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_ru(float x);
# 1883 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frcp_rd(float x);
# 1914 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rn(float x);
# 1945 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rz(float x);
# 1976 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_ru(float x);
# 2007 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fsqrt_rd(float x);
# 2046 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __frsqrt_rn(float x);
# 2057 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y);
# 2068 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y);
# 2079 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y);
# 2090 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y);
# 2099 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clz(int x);
# 2110 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffs(int x);
# 2119 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popc(unsigned int x);
# 2128 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x);
# 2137 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __clzll(long long int x);
# 2148 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __ffsll(long long int x);
# 2159 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __popcll(unsigned long long int x);
# 2168 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x);
# 2192 "/usr/local/cuda/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);
# 2204 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __hadd(int, int);
# 2217 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __rhadd(int, int);
# 2229 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int, unsigned int);
# 2242 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int, unsigned int);
# 2252 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) int __double2int_rz(double);
# 2261 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double);
# 2270 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) long long int __double2ll_rz(double);
# 2279 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double);
__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);
# 2309 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a);
# 2320 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a);
# 2331 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b);
# 2342 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b);
# 2352 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b);
# 2363 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b);
# 2374 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b);
# 2385 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b);
# 2396 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b);
# 2407 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b);
# 2418 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b);
# 2429 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b);
# 2440 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b);
# 2451 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b);
# 2463 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b);
# 2474 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b);
# 2485 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b);
# 2496 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b);
# 2507 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b);
# 2518 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b);
# 2529 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b);
# 2540 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b);
# 2551 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b);
# 2562 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b);
# 2573 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b);
# 2584 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b);
# 2595 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b);
# 2606 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b);
# 2617 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b);
# 2628 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b);
# 2639 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b);
# 2650 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b);
# 2661 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b);
# 2672 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b);
# 2683 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b);
# 2694 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b);
# 2705 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b);
# 2715 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a);
# 2725 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a);
# 2736 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b);
# 2747 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b);
# 2757 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a);
# 2768 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a);
# 2779 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b);
# 2790 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b);
# 2800 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b);
# 2811 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b);
# 2822 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b);
# 2833 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b);
# 2844 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b);
# 2855 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b);
# 2866 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b);
# 2877 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b);
# 2888 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b);
# 2899 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b);
# 2910 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b);
# 2921 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b);
# 2932 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b);
# 2943 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b);
# 2954 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b);
# 2965 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b);
# 2976 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b);
# 2987 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b);
# 2998 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b);
# 3009 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b);
# 3020 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b);
# 3031 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b);
# 3042 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b);
# 3053 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b);
# 3064 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b);
# 3075 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b);
# 3086 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b);
# 3097 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b);
# 3108 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b);
# 3119 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b);
# 3130 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b);
# 3141 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b);
# 3152 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b);
# 3162 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a);
# 3172 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a);
# 3183 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b);
# 3194 "/usr/local/cuda/include/crt/device_functions.h"
__attribute__((device)) __attribute__((cudart_builtin)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b);






}







static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int mulhi(int a, int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int mulhi(unsigned int a, unsigned int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int mulhi(int a, unsigned int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int mulhi(unsigned int a, int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) long long int mul64hi(long long int a, long long int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int mul64hi(unsigned long long int a, unsigned long long int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int mul64hi(long long int a, unsigned long long int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned long long int mul64hi(unsigned long long int a, long long int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int float_as_int(float a);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float int_as_float(int a);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int float_as_uint(float a);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float uint_as_float(unsigned int a);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float saturate(float a);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int mul24(int a, int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int umul24(unsigned int a, unsigned int b);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) int float2int(float a, enum cudaRoundMode mode = cudaRoundZero);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) unsigned int float2uint(float a, enum cudaRoundMode mode = cudaRoundZero);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float int2float(int a, enum cudaRoundMode mode = cudaRoundNearest);

static __inline__ __attribute__((device)) __attribute__((cudart_builtin)) float uint2float(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest);
# 3259 "/usr/local/cuda/include/crt/device_functions.h"
# 1 "/usr/local/cuda/include/crt/device_functions.hpp" 1
# 69 "/usr/local/cuda/include/crt/device_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/crt/device_functions.hpp" 2
# 80 "/usr/local/cuda/include/crt/device_functions.hpp"
static __inline__ __attribute__((device)) int mulhi(int a, int b)
{
  return __mulhi(a, b);
}

static __inline__ __attribute__((device)) unsigned int mulhi(unsigned int a, unsigned int b)
{
  return __umulhi(a, b);
}

static __inline__ __attribute__((device)) unsigned int mulhi(int a, unsigned int b)
{
  return __umulhi((unsigned int)a, b);
}

static __inline__ __attribute__((device)) unsigned int mulhi(unsigned int a, int b)
{
  return __umulhi(a, (unsigned int)b);
}

static __inline__ __attribute__((device)) long long int mul64hi(long long int a, long long int b)
{
  return __mul64hi(a, b);
}

static __inline__ __attribute__((device)) unsigned long long int mul64hi(unsigned long long int a, unsigned long long int b)
{
  return __umul64hi(a, b);
}

static __inline__ __attribute__((device)) unsigned long long int mul64hi(long long int a, unsigned long long int b)
{
  return __umul64hi((unsigned long long int)a, b);
}

static __inline__ __attribute__((device)) unsigned long long int mul64hi(unsigned long long int a, long long int b)
{
  return __umul64hi(a, (unsigned long long int)b);
}

static __inline__ __attribute__((device)) int float_as_int(float a)
{
  return __float_as_int(a);
}

static __inline__ __attribute__((device)) float int_as_float(int a)
{
  return __int_as_float(a);
}

static __inline__ __attribute__((device)) unsigned int float_as_uint(float a)
{
  return __float_as_uint(a);
}

static __inline__ __attribute__((device)) float uint_as_float(unsigned int a)
{
  return __uint_as_float(a);
}
static __inline__ __attribute__((device)) float saturate(float a)
{
  return __saturatef(a);
}

static __inline__ __attribute__((device)) int mul24(int a, int b)
{
  return __mul24(a, b);
}

static __inline__ __attribute__((device)) unsigned int umul24(unsigned int a, unsigned int b)
{
  return __umul24(a, b);
}

static __inline__ __attribute__((device)) int float2int(float a, enum cudaRoundMode mode)
{
  return mode == cudaRoundNearest ? __float2int_rn(a) :
         mode == cudaRoundPosInf ? __float2int_ru(a) :
         mode == cudaRoundMinInf ? __float2int_rd(a) :
                                    __float2int_rz(a);
}

static __inline__ __attribute__((device)) unsigned int float2uint(float a, enum cudaRoundMode mode)
{
  return mode == cudaRoundNearest ? __float2uint_rn(a) :
         mode == cudaRoundPosInf ? __float2uint_ru(a) :
         mode == cudaRoundMinInf ? __float2uint_rd(a) :
                                    __float2uint_rz(a);
}

static __inline__ __attribute__((device)) float int2float(int a, enum cudaRoundMode mode)
{
  return mode == cudaRoundZero ? __int2float_rz(a) :
         mode == cudaRoundPosInf ? __int2float_ru(a) :
         mode == cudaRoundMinInf ? __int2float_rd(a) :
                                   __int2float_rn(a);
}

static __inline__ __attribute__((device)) float uint2float(unsigned int a, enum cudaRoundMode mode)
{
  return mode == cudaRoundZero ? __uint2float_rz(a) :
         mode == cudaRoundPosInf ? __uint2float_ru(a) :
         mode == cudaRoundMinInf ? __uint2float_rd(a) :
                                   __uint2float_rn(a);
}
# 3260 "/usr/local/cuda/include/crt/device_functions.h" 2


# 1 "/usr/local/cuda/include/device_atomic_functions.h" 1
# 67 "/usr/local/cuda/include/device_atomic_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/device_atomic_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 69 "/usr/local/cuda/include/device_atomic_functions.h" 2
# 107 "/usr/local/cuda/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) { }







# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 156 "/usr/local/cuda/include/device_atomic_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 157 "/usr/local/cuda/include/device_atomic_functions.h" 2
# 173 "/usr/local/cuda/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);
}
# 191 "/usr/local/cuda/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) { }
# 3263 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/crt/device_double_functions.h" 1
# 73 "/usr/local/cuda/include/crt/device_double_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 74 "/usr/local/cuda/include/crt/device_double_functions.h" 2



extern "C"
{
# 87 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x);
# 96 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x);
# 253 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z);
# 410 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z);
# 567 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z);
# 724 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z);
# 736 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y);
# 748 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y);
# 760 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y);
# 772 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y);
# 784 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y);
# 796 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y);
# 808 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y);
# 820 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y);
# 832 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y);
# 844 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y);
# 856 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y);
# 868 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y);
# 877 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x);
# 886 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x);
# 895 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x);
# 904 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x);
# 913 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x);
# 922 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x);
# 931 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x);
# 940 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x);
# 949 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x);
# 958 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x);
# 967 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x);
# 976 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x);
# 985 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x);
# 994 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x);
# 1003 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x);
# 1012 "/usr/local/cuda/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);
# 1037 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x);
# 1046 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x);
# 1055 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x);
# 1064 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x);
# 1073 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x);
# 1082 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x);
# 1091 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x);
# 1100 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x);
# 1109 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x);
# 1118 "/usr/local/cuda/include/crt/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x);
# 1128 "/usr/local/cuda/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/include/crt/device_double_functions.hpp" 1
# 73 "/usr/local/cuda/include/crt/device_double_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 74 "/usr/local/cuda/include/crt/device_double_functions.hpp" 2
# 83 "/usr/local/cuda/include/crt/device_double_functions.hpp"
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;
}
# 1169 "/usr/local/cuda/include/crt/device_double_functions.h" 2
# 3264 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_20_atomic_functions.h" 1
# 67 "/usr/local/cuda/include/sm_20_atomic_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/sm_20_atomic_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 69 "/usr/local/cuda/include/sm_20_atomic_functions.h" 2
# 90 "/usr/local/cuda/include/sm_20_atomic_functions.h"
static __inline__ __attribute__((device)) float atomicAdd(float *address, float val) { }
# 3265 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_32_atomic_functions.h" 1
# 69 "/usr/local/cuda/include/sm_32_atomic_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/sm_32_atomic_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 71 "/usr/local/cuda/include/sm_32_atomic_functions.h" 2
# 101 "/usr/local/cuda/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) { }
# 3266 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_35_atomic_functions.h" 1
# 56 "/usr/local/cuda/include/sm_35_atomic_functions.h"
# 1 "/usr/local/cuda/include/sm_32_atomic_functions.h" 1
# 57 "/usr/local/cuda/include/sm_35_atomic_functions.h" 2
# 3267 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_60_atomic_functions.h" 1
# 70 "/usr/local/cuda/include/sm_60_atomic_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 71 "/usr/local/cuda/include/sm_60_atomic_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 72 "/usr/local/cuda/include/sm_60_atomic_functions.h" 2
# 304 "/usr/local/cuda/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) { }
# 3268 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_20_intrinsics.h" 1
# 67 "/usr/local/cuda/include/sm_20_intrinsics.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/sm_20_intrinsics.h" 2

# 1 "/usr/local/cuda/include/host_defines.h" 1
# 70 "/usr/local/cuda/include/sm_20_intrinsics.h" 2
# 92 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern "C"
{
extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void);
# 106 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y);
# 118 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y);
# 130 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y);
# 142 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y);
# 176 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x);
# 210 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x);
# 244 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x);
# 278 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x);
# 310 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x);
# 342 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x);
# 374 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x);
# 406 "/usr/local/cuda/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);






extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rn(float, float, float);
extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rz(float, float, float);
extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_ru(float, float, float);
extern __attribute__((device)) __attribute__((device_builtin)) float __fmaf_ieee_rd(float, float, float);
# 433 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x);
# 442 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x);
# 599 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z);
# 756 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z);
# 913 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z);
# 1070 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z);
# 1082 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y);
# 1094 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y);
# 1106 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y);
# 1118 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y);
# 1130 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y);
# 1142 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y);
# 1154 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y);
# 1166 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y);
# 1178 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y);
# 1190 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y);
# 1202 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y);
# 1214 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y);
# 1223 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x);
# 1232 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x);
# 1241 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x);
# 1250 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x);
# 1259 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x);
# 1268 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x);
# 1277 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x);
# 1286 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x);
# 1295 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x);
# 1304 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x);
# 1313 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x);
# 1322 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x);
# 1331 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x);
# 1340 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x);
# 1349 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x);
# 1358 "/usr/local/cuda/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);
# 1383 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x);
# 1392 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x);
# 1401 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x);
# 1410 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x);
# 1419 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x);
# 1428 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x);
# 1437 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x);
# 1446 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x);
# 1455 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x);
# 1464 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x);
# 1474 "/usr/local/cuda/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) { }
# 3269 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_30_intrinsics.h" 1
# 69 "/usr/local/cuda/include/sm_30_intrinsics.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/sm_30_intrinsics.h" 2

# 1 "/usr/local/cuda/include/host_defines.h" 1
# 72 "/usr/local/cuda/include/sm_30_intrinsics.h" 2
# 107 "/usr/local/cuda/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() { }







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__ int __shfl_sync(unsigned mask, 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__ unsigned int __shfl_sync(unsigned mask, 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__ int __shfl_up_sync(unsigned mask, 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__ unsigned int __shfl_up_sync(unsigned mask, 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__ int __shfl_down_sync(unsigned mask, 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__ unsigned int __shfl_down_sync(unsigned mask, 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__ int __shfl_xor_sync(unsigned mask, 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__ unsigned int __shfl_xor_sync(unsigned mask, 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__ float __shfl_sync(unsigned mask, 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__ float __shfl_up_sync(unsigned mask, 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__ float __shfl_down_sync(unsigned mask, 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__ 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)."))) long long __shfl(long long var, int srcLane, 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__ __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__ unsigned long long __shfl_sync(unsigned mask, unsigned 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__ long long __shfl_up_sync(unsigned mask, 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__ unsigned long long __shfl_up_sync(unsigned mask, 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__ long long __shfl_down_sync(unsigned mask, 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__ unsigned long long __shfl_down_sync(unsigned mask, 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__ long long __shfl_xor_sync(unsigned mask, 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__ unsigned long long __shfl_xor_sync(unsigned mask, 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__ double __shfl_sync(unsigned mask, 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__ double __shfl_up_sync(unsigned mask, 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__ double __shfl_down_sync(unsigned mask, 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__ 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__ long __shfl_sync(unsigned mask, 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__ unsigned long __shfl_sync(unsigned mask, 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__ long __shfl_up_sync(unsigned mask, 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__ unsigned long __shfl_up_sync(unsigned mask, 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__ long __shfl_down_sync(unsigned mask, 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__ unsigned long __shfl_down_sync(unsigned mask, 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__ long __shfl_xor_sync(unsigned mask, 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__ unsigned long __shfl_xor_sync(unsigned mask, unsigned long var, int laneMask, int width=32) { }
# 3270 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_32_intrinsics.h" 1
# 69 "/usr/local/cuda/include/sm_32_intrinsics.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/sm_32_intrinsics.h" 2

# 1 "/usr/local/cuda/include/host_defines.h" 1
# 72 "/usr/local/cuda/include/sm_32_intrinsics.h" 2
# 89 "/usr/local/cuda/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__ unsigned int __funnelshift_l(unsigned int lo, unsigned int hi, unsigned int shift) { }
static __attribute__((device)) __inline__ unsigned int __funnelshift_lc(unsigned int lo, unsigned int hi, unsigned int shift) { }


static __attribute__((device)) __inline__ unsigned int __funnelshift_r(unsigned int lo, unsigned int hi, unsigned int shift) { }
static __attribute__((device)) __inline__ unsigned int __funnelshift_rc(unsigned int lo, unsigned int hi, unsigned int shift) { }
# 3271 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_35_intrinsics.h" 1
# 111 "/usr/local/cuda/include/sm_35_intrinsics.h"
# 1 "/usr/local/cuda/include/sm_32_intrinsics.h" 1
# 112 "/usr/local/cuda/include/sm_35_intrinsics.h" 2
# 3272 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_61_intrinsics.h" 1
# 69 "/usr/local/cuda/include/sm_61_intrinsics.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/sm_61_intrinsics.h" 2

# 1 "/usr/local/cuda/include/host_defines.h" 1
# 72 "/usr/local/cuda/include/sm_61_intrinsics.h" 2
# 91 "/usr/local/cuda/include/sm_61_intrinsics.h"
static __attribute__((device)) __inline__ int __dp2a_lo(int srcA, int srcB, int c) { }
static __attribute__((device)) __inline__ unsigned int __dp2a_lo(unsigned int srcA, unsigned int srcB, unsigned int c) { }

static __attribute__((device)) __inline__ int __dp2a_lo(short2 srcA, char4 srcB, int c) { }
static __attribute__((device)) __inline__ unsigned int __dp2a_lo(ushort2 srcA, uchar4 srcB, unsigned int c) { }

static __attribute__((device)) __inline__ int __dp2a_hi(int srcA, int srcB, int c) { }
static __attribute__((device)) __inline__ unsigned int __dp2a_hi(unsigned int srcA, unsigned int srcB, unsigned int c) { }

static __attribute__((device)) __inline__ int __dp2a_hi(short2 srcA, char4 srcB, int c) { }
static __attribute__((device)) __inline__ unsigned int __dp2a_hi(ushort2 srcA, uchar4 srcB, unsigned int c) { }






static __attribute__((device)) __inline__ int __dp4a(int srcA, int srcB, int c) { }
static __attribute__((device)) __inline__ unsigned int __dp4a(unsigned int srcA, unsigned int srcB, unsigned int c) { }

static __attribute__((device)) __inline__ int __dp4a(char4 srcA, char4 srcB, int c) { }
static __attribute__((device)) __inline__ unsigned int __dp4a(uchar4 srcA, uchar4 srcB, unsigned int c) { }
# 3273 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/crt/sm_70_rt.h" 1
# 69 "/usr/local/cuda/include/crt/sm_70_rt.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/crt/sm_70_rt.h" 2
# 83 "/usr/local/cuda/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) { }
# 3274 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/surface_functions.h" 1
# 61 "/usr/local/cuda/include/surface_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 62 "/usr/local/cuda/include/surface_functions.h" 2

# 1 "/usr/local/cuda/include/host_defines.h" 1
# 64 "/usr/local/cuda/include/surface_functions.h" 2
# 116 "/usr/local/cuda/include/surface_functions.h"
template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dread(T *res, surface<void, 0x01> surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{





}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dread(T *res, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dread(T *res, surface<void, 0x02> surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{





}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dread(T *res, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dread(T *res, surface<void, 0x03> surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{





}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dread(T *res, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}



template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredread(T *res, surface<void, 0xF1> surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{





}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredread(T *res, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredread(T *res, surface<void, 0xF2> surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{





}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredread(T *res, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapread(T *res, surface<void, 0x0C> surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{






}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapread(T *res, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredread(T *res, surface<void, 0xFC> surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) T surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{





}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredread(T *res, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dwrite(T val, surface<void, 0x01> surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1Dwrite(T val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}



template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dwrite(T val, surface<void, 0x02> surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2Dwrite(T val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dwrite(T val, surface<void, 0x03> surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf3Dwrite(T val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredwrite(T val, surface<void, 0xF1> surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf1DLayeredwrite(T val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredwrite(T val, surface<void, 0xF2> surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surf2DLayeredwrite(T val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}


template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapwrite(T val, surface<void, 0x0C> surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapwrite(T val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}



template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredwrite(T val, surface<void, 0xFC> surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template<class T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) void surfCubemapLayeredwrite(T val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}
# 3275 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/texture_fetch_functions.h" 1
# 62 "/usr/local/cuda/include/texture_fetch_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 63 "/usr/local/cuda/include/texture_fetch_functions.h" 2

# 1 "/usr/local/cuda/include/host_defines.h" 1
# 65 "/usr/local/cuda/include/texture_fetch_functions.h" 2



template <typename T>
struct __nv_tex_rmet_ret { };

template<> struct __nv_tex_rmet_ret<char> { typedef char type; };
template<> struct __nv_tex_rmet_ret<signed char> { typedef signed char type; };
template<> struct __nv_tex_rmet_ret<unsigned char> { typedef unsigned char type; };
template<> struct __nv_tex_rmet_ret<char1> { typedef char1 type; };
template<> struct __nv_tex_rmet_ret<uchar1> { typedef uchar1 type; };
template<> struct __nv_tex_rmet_ret<char2> { typedef char2 type; };
template<> struct __nv_tex_rmet_ret<uchar2> { typedef uchar2 type; };
template<> struct __nv_tex_rmet_ret<char4> { typedef char4 type; };
template<> struct __nv_tex_rmet_ret<uchar4> { typedef uchar4 type; };

template<> struct __nv_tex_rmet_ret<short> { typedef short type; };
template<> struct __nv_tex_rmet_ret<unsigned short> { typedef unsigned short type; };
template<> struct __nv_tex_rmet_ret<short1> { typedef short1 type; };
template<> struct __nv_tex_rmet_ret<ushort1> { typedef ushort1 type; };
template<> struct __nv_tex_rmet_ret<short2> { typedef short2 type; };
template<> struct __nv_tex_rmet_ret<ushort2> { typedef ushort2 type; };
template<> struct __nv_tex_rmet_ret<short4> { typedef short4 type; };
template<> struct __nv_tex_rmet_ret<ushort4> { typedef ushort4 type; };

template<> struct __nv_tex_rmet_ret<int> { typedef int type; };
template<> struct __nv_tex_rmet_ret<unsigned int> { typedef unsigned int type; };
template<> struct __nv_tex_rmet_ret<int1> { typedef int1 type; };
template<> struct __nv_tex_rmet_ret<uint1> { typedef uint1 type; };
template<> struct __nv_tex_rmet_ret<int2> { typedef int2 type; };
template<> struct __nv_tex_rmet_ret<uint2> { typedef uint2 type; };
template<> struct __nv_tex_rmet_ret<int4> { typedef int4 type; };
template<> struct __nv_tex_rmet_ret<uint4> { typedef uint4 type; };
# 109 "/usr/local/cuda/include/texture_fetch_functions.h"
template<> struct __nv_tex_rmet_ret<float> { typedef float type; };
template<> struct __nv_tex_rmet_ret<float1> { typedef float1 type; };
template<> struct __nv_tex_rmet_ret<float2> { typedef float2 type; };
template<> struct __nv_tex_rmet_ret<float4> { typedef float4 type; };


template <typename T> struct __nv_tex_rmet_cast { typedef T* type; };
# 127 "/usr/local/cuda/include/texture_fetch_functions.h"
template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1Dfetch(texture<T, 0x01, cudaReadModeElementType> t, int x)
{





}

template <typename T>
struct __nv_tex_rmnf_ret { };

template <> struct __nv_tex_rmnf_ret<char> { typedef float type; };
template <> struct __nv_tex_rmnf_ret<signed char> { typedef float type; };
template <> struct __nv_tex_rmnf_ret<unsigned char> { typedef float type; };
template <> struct __nv_tex_rmnf_ret<short> { typedef float type; };
template <> struct __nv_tex_rmnf_ret<unsigned short> { typedef float type; };
template <> struct __nv_tex_rmnf_ret<char1> { typedef float1 type; };
template <> struct __nv_tex_rmnf_ret<uchar1> { typedef float1 type; };
template <> struct __nv_tex_rmnf_ret<short1> { typedef float1 type; };
template <> struct __nv_tex_rmnf_ret<ushort1> { typedef float1 type; };
template <> struct __nv_tex_rmnf_ret<char2> { typedef float2 type; };
template <> struct __nv_tex_rmnf_ret<uchar2> { typedef float2 type; };
template <> struct __nv_tex_rmnf_ret<short2> { typedef float2 type; };
template <> struct __nv_tex_rmnf_ret<ushort2> { typedef float2 type; };
template <> struct __nv_tex_rmnf_ret<char4> { typedef float4 type; };
template <> struct __nv_tex_rmnf_ret<uchar4> { typedef float4 type; };
template <> struct __nv_tex_rmnf_ret<short4> { typedef float4 type; };
template <> struct __nv_tex_rmnf_ret<ushort4> { typedef float4 type; };

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1Dfetch(texture<T, 0x01, cudaReadModeNormalizedFloat> t, int x)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1D(texture<T, 0x01, cudaReadModeElementType> t, float x)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1D(texture<T, 0x01, cudaReadModeNormalizedFloat> t, float x)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex2D(texture<T, 0x02, cudaReadModeElementType> t, float x, float y)
{






}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex2D(texture<T, 0x02, cudaReadModeNormalizedFloat> t, float x, float y)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1DLayered(texture<T, 0xF1, cudaReadModeElementType> t, float x, int layer)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1DLayered(texture<T, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex2DLayered(texture<T, 0xF2, cudaReadModeElementType> t, float x, float y, int layer)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex2DLayered(texture<T, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex3D(texture<T, 0x03, cudaReadModeElementType> t, float x, float y, float z)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex3D(texture<T, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type texCubemap(texture<T, 0x0C, cudaReadModeElementType> t, float x, float y, float z)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type texCubemap(texture<T, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z)
{






}


template <typename T>
struct __nv_tex2dgather_ret { };
template <> struct __nv_tex2dgather_ret<char> { typedef char4 type; };
template <> struct __nv_tex2dgather_ret<signed char> { typedef char4 type; };
template <> struct __nv_tex2dgather_ret<char1> { typedef char4 type; };
template <> struct __nv_tex2dgather_ret<char2> { typedef char4 type; };
template <> struct __nv_tex2dgather_ret<char3> { typedef char4 type; };
template <> struct __nv_tex2dgather_ret<char4> { typedef char4 type; };
template <> struct __nv_tex2dgather_ret<unsigned char> { typedef uchar4 type; };
template <> struct __nv_tex2dgather_ret<uchar1> { typedef uchar4 type; };
template <> struct __nv_tex2dgather_ret<uchar2> { typedef uchar4 type; };
template <> struct __nv_tex2dgather_ret<uchar3> { typedef uchar4 type; };
template <> struct __nv_tex2dgather_ret<uchar4> { typedef uchar4 type; };

template <> struct __nv_tex2dgather_ret<short> { typedef short4 type; };
template <> struct __nv_tex2dgather_ret<short1> { typedef short4 type; };
template <> struct __nv_tex2dgather_ret<short2> { typedef short4 type; };
template <> struct __nv_tex2dgather_ret<short3> { typedef short4 type; };
template <> struct __nv_tex2dgather_ret<short4> { typedef short4 type; };
template <> struct __nv_tex2dgather_ret<unsigned short> { typedef ushort4 type; };
template <> struct __nv_tex2dgather_ret<ushort1> { typedef ushort4 type; };
template <> struct __nv_tex2dgather_ret<ushort2> { typedef ushort4 type; };
template <> struct __nv_tex2dgather_ret<ushort3> { typedef ushort4 type; };
template <> struct __nv_tex2dgather_ret<ushort4> { typedef ushort4 type; };

template <> struct __nv_tex2dgather_ret<int> { typedef int4 type; };
template <> struct __nv_tex2dgather_ret<int1> { typedef int4 type; };
template <> struct __nv_tex2dgather_ret<int2> { typedef int4 type; };
template <> struct __nv_tex2dgather_ret<int3> { typedef int4 type; };
template <> struct __nv_tex2dgather_ret<int4> { typedef int4 type; };
template <> struct __nv_tex2dgather_ret<unsigned int> { typedef uint4 type; };
template <> struct __nv_tex2dgather_ret<uint1> { typedef uint4 type; };
template <> struct __nv_tex2dgather_ret<uint2> { typedef uint4 type; };
template <> struct __nv_tex2dgather_ret<uint3> { typedef uint4 type; };
template <> struct __nv_tex2dgather_ret<uint4> { typedef uint4 type; };

template <> struct __nv_tex2dgather_ret<float> { typedef float4 type; };
template <> struct __nv_tex2dgather_ret<float1> { typedef float4 type; };
template <> struct __nv_tex2dgather_ret<float2> { typedef float4 type; };
template <> struct __nv_tex2dgather_ret<float3> { typedef float4 type; };
template <> struct __nv_tex2dgather_ret<float4> { typedef float4 type; };

template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) typename __nv_tex2dgather_ret<T>::type tex2Dgather(texture<T, 0x02, cudaReadModeElementType> t, float x, float y, int comp=0)
{






}


template<typename T> struct __nv_tex2dgather_rmnf_ret { };
template<> struct __nv_tex2dgather_rmnf_ret<char> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<signed char> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<unsigned char> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<char1> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<uchar1> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<char2> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<uchar2> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<char3> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<uchar3> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<char4> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<uchar4> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<signed short> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<unsigned short> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<short1> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<ushort1> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<short2> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<ushort2> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<short3> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<ushort3> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<short4> { typedef float4 type; };
template<> struct __nv_tex2dgather_rmnf_ret<ushort4> { typedef float4 type; };

template <typename T>
static __attribute__((device)) __inline__ __attribute__((always_inline)) typename __nv_tex2dgather_rmnf_ret<T>::type tex2Dgather(texture<T, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1DLod(texture<T, 0x01, cudaReadModeElementType> t, float x, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1DLod(texture<T, 0x01, cudaReadModeNormalizedFloat> t, float x, float level)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex2DLod(texture<T, 0x02, cudaReadModeElementType> t, float x, float y, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex2DLod(texture<T, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1DLayeredLod(texture<T, 0xF1, cudaReadModeElementType> t, float x, int layer, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1DLayeredLod(texture<T, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex2DLayeredLod(texture<T, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex2DLayeredLod(texture<T, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex3DLod(texture<T, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex3DLod(texture<T, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type texCubemapLod(texture<T, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type texCubemapLod(texture<T, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type texCubemapLayered(texture<T, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type texCubemapLayered(texture<T, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type texCubemapLayeredLod(texture<T, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type texCubemapLayeredLod(texture<T, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type texCubemapGrad(texture<T, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float4 dPdx, float4 dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type texCubemapGrad(texture<T, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float4 dPdx, float4 dPdy)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type texCubemapLayeredGrad(texture<T, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float4 dPdx, float4 dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type texCubemapLayeredGrad(texture<T, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float4 dPdx, float4 dPdy)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1DGrad(texture<T, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1DGrad(texture<T, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy)
{






}



template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex2DGrad(texture<T, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex2DGrad(texture<T, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float2 dPdx, float2 dPdy)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex1DLayeredGrad(texture<T, 0xF1, cudaReadModeElementType> t, float x, int layer, float dPdx, float dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex1DLayeredGrad(texture<T, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float dPdx, float dPdy)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex2DLayeredGrad(texture<T, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float2 dPdx, float2 dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex2DLayeredGrad(texture<T, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float2 dPdx, float2 dPdy)
{






}


template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmet_ret<T>::type tex3DGrad(texture<T, 0x03, cudaReadModeElementType> t, float x, float y, float z, float4 dPdx, float4 dPdy)
{





}

template <typename T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) typename __nv_tex_rmnf_ret<T>::type tex3DGrad(texture<T, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float4 dPdx, float4 dPdy)
{






}
# 3276 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/texture_indirect_functions.h" 1
# 57 "/usr/local/cuda/include/texture_indirect_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 58 "/usr/local/cuda/include/texture_indirect_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 59 "/usr/local/cuda/include/texture_indirect_functions.h" 2


template <typename T> struct __nv_itex_trait { };
template<> struct __nv_itex_trait<char> { typedef void type; };
template<> struct __nv_itex_trait<signed char> { typedef void type; };
template<> struct __nv_itex_trait<char1> { typedef void type; };
template<> struct __nv_itex_trait<char2> { typedef void type; };
template<> struct __nv_itex_trait<char4> { typedef void type; };
template<> struct __nv_itex_trait<unsigned char> { typedef void type; };
template<> struct __nv_itex_trait<uchar1> { typedef void type; };
template<> struct __nv_itex_trait<uchar2> { typedef void type; };
template<> struct __nv_itex_trait<uchar4> { typedef void type; };
template<> struct __nv_itex_trait<short> { typedef void type; };
template<> struct __nv_itex_trait<short1> { typedef void type; };
template<> struct __nv_itex_trait<short2> { typedef void type; };
template<> struct __nv_itex_trait<short4> { typedef void type; };
template<> struct __nv_itex_trait<unsigned short> { typedef void type; };
template<> struct __nv_itex_trait<ushort1> { typedef void type; };
template<> struct __nv_itex_trait<ushort2> { typedef void type; };
template<> struct __nv_itex_trait<ushort4> { typedef void type; };
template<> struct __nv_itex_trait<int> { typedef void type; };
template<> struct __nv_itex_trait<int1> { typedef void type; };
template<> struct __nv_itex_trait<int2> { typedef void type; };
template<> struct __nv_itex_trait<int4> { typedef void type; };
template<> struct __nv_itex_trait<unsigned int> { typedef void type; };
template<> struct __nv_itex_trait<uint1> { typedef void type; };
template<> struct __nv_itex_trait<uint2> { typedef void type; };
template<> struct __nv_itex_trait<uint4> { typedef void type; };
# 97 "/usr/local/cuda/include/texture_indirect_functions.h"
template<> struct __nv_itex_trait<float> { typedef void type; };
template<> struct __nv_itex_trait<float1> { typedef void type; };
template<> struct __nv_itex_trait<float2> { typedef void type; };
template<> struct __nv_itex_trait<float4> { typedef void type; };



template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1Dfetch(T *ptr, cudaTextureObject_t obj, int x)
{



}

template <class T>
static __attribute__((device)) T tex1Dfetch(cudaTextureObject_t texObject, int x)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1D(T *ptr, cudaTextureObject_t obj, float x)
{



}


template <class T>
static __attribute__((device)) T tex1D(cudaTextureObject_t texObject, float x)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2D(T *ptr, cudaTextureObject_t obj, float x, float y)
{



}

template <class T>
static __attribute__((device)) T tex2D(cudaTextureObject_t texObject, float x, float y)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex3D(T *ptr, cudaTextureObject_t obj, float x, float y, float z)
{



}

template <class T>
static __attribute__((device)) T tex3D(cudaTextureObject_t texObject, float x, float y, float z)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1DLayered(T *ptr, cudaTextureObject_t obj, float x, int layer)
{



}

template <class T>
static __attribute__((device)) T tex1DLayered(cudaTextureObject_t texObject, float x, int layer)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2DLayered(T *ptr, cudaTextureObject_t obj, float x, float y, int layer)
{



}

template <class T>
static __attribute__((device)) T tex2DLayered(cudaTextureObject_t texObject, float x, float y, int layer)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type texCubemap(T *ptr, cudaTextureObject_t obj, float x, float y, float z)
{



}


template <class T>
static __attribute__((device)) T texCubemap(cudaTextureObject_t texObject, float x, float y, float z)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type texCubemapLayered(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer)
{



}

template <class T>
static __attribute__((device)) T texCubemapLayered(cudaTextureObject_t texObject, float x, float y, float z, int layer)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2Dgather(T *ptr, cudaTextureObject_t obj, float x, float y, int comp = 0)
{



}

template <class T>
static __attribute__((device)) T tex2Dgather(cudaTextureObject_t to, float x, float y, int comp = 0)
{





}



template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1DLod(T *ptr, cudaTextureObject_t obj, float x, float level)
{



}

template <class T>
static __attribute__((device)) T tex1DLod(cudaTextureObject_t texObject, float x, float level)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float level)
{



}

template <class T>
static __attribute__((device)) T tex2DLod(cudaTextureObject_t texObject, float x, float y, float level)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex3DLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level)
{



}

template <class T>
static __attribute__((device)) T tex3DLod(cudaTextureObject_t texObject, float x, float y, float z, float level)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, int layer, float level)
{



}

template <class T>
static __attribute__((device)) T tex1DLayeredLod(cudaTextureObject_t texObject, float x, int layer, float level)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2DLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, int layer, float level)
{



}

template <class T>
static __attribute__((device)) T tex2DLayeredLod(cudaTextureObject_t texObject, float x, float y, int layer, float level)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type texCubemapLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float level)
{



}

template <class T>
static __attribute__((device)) T texCubemapLod(cudaTextureObject_t texObject, float x, float y, float z, float level)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type texCubemapGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy)
{



}

template <class T>
static __attribute__((device)) T texCubemapGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type texCubemapLayeredLod(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float level)
{



}

template <class T>
static __attribute__((device)) T texCubemapLayeredLod(cudaTextureObject_t texObject, float x, float y, float z, int layer, float level)
{





}

template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1DGrad(T *ptr, cudaTextureObject_t obj, float x, float dPdx, float dPdy)
{



}

template <class T>
static __attribute__((device)) T tex1DGrad(cudaTextureObject_t texObject, float x, float dPdx, float dPdy)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float2 dPdx, float2 dPdy)
{




}

template <class T>
static __attribute__((device)) T tex2DGrad(cudaTextureObject_t texObject, float x, float y, float2 dPdx, float2 dPdy)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex3DGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, float4 dPdx, float4 dPdy)
{



}

template <class T>
static __attribute__((device)) T tex3DGrad(cudaTextureObject_t texObject, float x, float y, float z, float4 dPdx, float4 dPdy)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex1DLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, int layer, float dPdx, float dPdy)
{



}

template <class T>
static __attribute__((device)) T tex1DLayeredGrad(cudaTextureObject_t texObject, float x, int layer, float dPdx, float dPdy)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type tex2DLayeredGrad(T * ptr, cudaTextureObject_t obj, float x, float y, int layer, float2 dPdx, float2 dPdy)
{



}

template <class T>
static __attribute__((device)) T tex2DLayeredGrad(cudaTextureObject_t texObject, float x, float y, int layer, float2 dPdx, float2 dPdy)
{





}


template <typename T>
static __attribute__((device)) typename __nv_itex_trait<T>::type texCubemapLayeredGrad(T *ptr, cudaTextureObject_t obj, float x, float y, float z, int layer, float4 dPdx, float4 dPdy)
{



}

template <class T>
static __attribute__((device)) T texCubemapLayeredGrad(cudaTextureObject_t texObject, float x, float y, float z, int layer, float4 dPdx, float4 dPdy)
{





}
# 3277 "/usr/local/cuda/include/crt/device_functions.h" 2
# 1 "/usr/local/cuda/include/surface_indirect_functions.h" 1
# 57 "/usr/local/cuda/include/surface_indirect_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 58 "/usr/local/cuda/include/surface_indirect_functions.h" 2
# 1 "/usr/local/cuda/include/host_defines.h" 1
# 59 "/usr/local/cuda/include/surface_indirect_functions.h" 2

template<typename T> struct __nv_isurf_trait { };
template<> struct __nv_isurf_trait<char> { typedef void type; };
template<> struct __nv_isurf_trait<signed char> { typedef void type; };
template<> struct __nv_isurf_trait<char1> { typedef void type; };
template<> struct __nv_isurf_trait<unsigned char> { typedef void type; };
template<> struct __nv_isurf_trait<uchar1> { typedef void type; };
template<> struct __nv_isurf_trait<short> { typedef void type; };
template<> struct __nv_isurf_trait<short1> { typedef void type; };
template<> struct __nv_isurf_trait<unsigned short> { typedef void type; };
template<> struct __nv_isurf_trait<ushort1> { typedef void type; };
template<> struct __nv_isurf_trait<int> { typedef void type; };
template<> struct __nv_isurf_trait<int1> { typedef void type; };
template<> struct __nv_isurf_trait<unsigned int> { typedef void type; };
template<> struct __nv_isurf_trait<uint1> { typedef void type; };
template<> struct __nv_isurf_trait<long long> { typedef void type; };
template<> struct __nv_isurf_trait<longlong1> { typedef void type; };
template<> struct __nv_isurf_trait<unsigned long long> { typedef void type; };
template<> struct __nv_isurf_trait<ulonglong1> { typedef void type; };
template<> struct __nv_isurf_trait<float> { typedef void type; };
template<> struct __nv_isurf_trait<float1> { typedef void type; };

template<> struct __nv_isurf_trait<char2> { typedef void type; };
template<> struct __nv_isurf_trait<uchar2> { typedef void type; };
template<> struct __nv_isurf_trait<short2> { typedef void type; };
template<> struct __nv_isurf_trait<ushort2> { typedef void type; };
template<> struct __nv_isurf_trait<int2> { typedef void type; };
template<> struct __nv_isurf_trait<uint2> { typedef void type; };
template<> struct __nv_isurf_trait<longlong2> { typedef void type; };
template<> struct __nv_isurf_trait<ulonglong2> { typedef void type; };
template<> struct __nv_isurf_trait<float2> { typedef void type; };

template<> struct __nv_isurf_trait<char4> { typedef void type; };
template<> struct __nv_isurf_trait<uchar4> { typedef void type; };
template<> struct __nv_isurf_trait<short4> { typedef void type; };
template<> struct __nv_isurf_trait<ushort4> { typedef void type; };
template<> struct __nv_isurf_trait<int4> { typedef void type; };
template<> struct __nv_isurf_trait<uint4> { typedef void type; };
template<> struct __nv_isurf_trait<float4> { typedef void type; };


template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf1Dread(T *ptr, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surf1Dread(cudaSurfaceObject_t surfObject, int x, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf2Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surf2Dread(cudaSurfaceObject_t surfObject, int x, int y, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}


template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf3Dread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surf3Dread(cudaSurfaceObject_t surfObject, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf1DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surf1DLayeredread(cudaSurfaceObject_t surfObject, int x, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf2DLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surf2DLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layer, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surfCubemapread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surfCubemapread(cudaSurfaceObject_t surfObject, int x, int y, int face, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surfCubemapLayeredread(T *ptr, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <class T>
static __attribute__((device)) T surfCubemapLayeredread(cudaSurfaceObject_t surfObject, int x, int y, int layerface, cudaSurfaceBoundaryMode boundaryMode = cudaBoundaryModeTrap)
{





}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf1Dwrite(T val, cudaSurfaceObject_t obj, int x, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf2Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf3Dwrite(T val, cudaSurfaceObject_t obj, int x, int y, int z, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf1DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surf2DLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layer, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surfCubemapwrite(T val, cudaSurfaceObject_t obj, int x, int y, int face, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}

template <typename T>
static __attribute__((device)) typename __nv_isurf_trait<T>::type surfCubemapLayeredwrite(T val, cudaSurfaceObject_t obj, int x, int y, int layerface, cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{



}
# 3278 "/usr/local/cuda/include/crt/device_functions.h" 2
# 50 "/usr/local/cuda/include/device_functions.h" 2
# 119 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/device_launch_parameters.h" 1
# 68 "/usr/local/cuda/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/include/cuda_runtime.h" 2
# 185 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 245 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 283 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaSetupArgument(
  T arg,
  size_t offset
)
{
  return ::cudaSetupArgument((const void*)&arg, sizeof(T), offset);
}
# 322 "/usr/local/cuda/include/cuda_runtime.h"
static __inline__ __attribute__((host)) cudaError_t cudaEventCreate(
  cudaEvent_t *event,
  unsigned int flags
)
{
  return ::cudaEventCreateWithFlags(event, flags);
}
# 385 "/usr/local/cuda/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<class T>
static __inline__ __attribute__((host)) cudaError_t cudaHostAlloc(
  T **ptr,
  size_t size,
  unsigned int flags
)
{
  return ::cudaHostAlloc((void**)(void*)ptr, size, flags);
}

template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaHostGetDevicePointer(
  T **pDevice,
  void *pHost,
  unsigned int flags
)
{
  return ::cudaHostGetDevicePointer((void**)(void*)pDevice, pHost, flags);
}
# 512 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaMallocManaged(
  T **devPtr,
  size_t size,
  unsigned int flags = 0x01
)
{
  return ::cudaMallocManaged((void**)(void*)devPtr, size, flags);
}
# 591 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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<class T>
static __inline__ __attribute__((host)) cudaError_t cudaMalloc(
  T **devPtr,
  size_t size
)
{
  return ::cudaMalloc((void**)(void*)devPtr, size);
}

template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaMallocHost(
  T **ptr,
  size_t size,
  unsigned int flags = 0
)
{
  return cudaMallocHost((void**)(void*)ptr, size, flags);
}

template<class T>
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);
}
# 667 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 719 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 765 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 817 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 851 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolAddress(
        void **devPtr,
  const T &symbol
)
{
  return ::cudaGetSymbolAddress(devPtr, (const void*)&symbol);
}
# 881 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaGetSymbolSize(
        size_t *size,
  const T &symbol
)
{
  return ::cudaGetSymbolSize(size, (const void*)&symbol);
}
# 923 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTexture(
        size_t *offset,
  const struct texture<T, dim, readMode> &tex,
  const void *devPtr,
  const struct cudaChannelFormatDesc &desc,
        size_t size = 
# 929 "/usr/local/cuda/include/cuda_runtime.h" 3 4
                                                (0x7fffffff * 2U + 1U)

# 930 "/usr/local/cuda/include/cuda_runtime.h"
)
{
  return ::cudaBindTexture(offset, &tex, devPtr, &desc, size);
}
# 967 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTexture(
        size_t *offset,
  const struct texture<T, dim, readMode> &tex,
  const void *devPtr,
        size_t size = 
# 972 "/usr/local/cuda/include/cuda_runtime.h" 3 4
                                                (0x7fffffff * 2U + 1U)

# 973 "/usr/local/cuda/include/cuda_runtime.h"
)
{
  return cudaBindTexture(offset, tex, devPtr, tex.channelDesc, size);
}
# 1022 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTexture2D(
        size_t *offset,
  const struct texture<T, dim, readMode> &tex,
  const void *devPtr,
  const struct cudaChannelFormatDesc &desc,
  size_t width,
  size_t height,
  size_t pitch
)
{
  return ::cudaBindTexture2D(offset, &tex, devPtr, &desc, width, height, pitch);
}
# 1079 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTexture2D(
        size_t *offset,
  const struct texture<T, dim, readMode> &tex,
  const void *devPtr,
  size_t width,
  size_t height,
  size_t pitch
)
{
  return ::cudaBindTexture2D(offset, &tex, devPtr, &tex.channelDesc, width, height, pitch);
}
# 1120 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToArray(
  const struct texture<T, dim, readMode> &tex,
  cudaArray_const_t array,
  const struct cudaChannelFormatDesc &desc
)
{
  return ::cudaBindTextureToArray(&tex, array, &desc);
}
# 1157 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToArray(
  const struct texture<T, dim, readMode> &tex,
  cudaArray_const_t array
)
{
  struct cudaChannelFormatDesc desc;
  cudaError_t err = ::cudaGetChannelDesc(&desc, array);

  return err == cudaSuccess ? cudaBindTextureToArray(tex, array, desc) : err;
}
# 1197 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToMipmappedArray(
  const struct texture<T, dim, readMode> &tex,
  cudaMipmappedArray_const_t mipmappedArray,
  const struct cudaChannelFormatDesc &desc
)
{
  return ::cudaBindTextureToMipmappedArray(&tex, mipmappedArray, &desc);
}
# 1234 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaBindTextureToMipmappedArray(
  const struct texture<T, dim, readMode> &tex,
  cudaMipmappedArray_const_t mipmappedArray
)
{
  struct cudaChannelFormatDesc desc;
  cudaArray_t levelArray;
  cudaError_t err = ::cudaGetMipmappedArrayLevel(&levelArray, mipmappedArray, 0);

  if (err != cudaSuccess) {
      return err;
  }
  err = ::cudaGetChannelDesc(&desc, levelArray);

  return err == cudaSuccess ? cudaBindTextureToMipmappedArray(tex, mipmappedArray, desc) : err;
}
# 1273 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaUnbindTexture(
  const struct texture<T, dim, readMode> &tex
)
{
  return ::cudaUnbindTexture(&tex);
}
# 1307 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((host)) cudaError_t cudaGetTextureAlignmentOffset(
        size_t *offset,
  const struct texture<T, dim, readMode> &tex
)
{
  return ::cudaGetTextureAlignmentOffset(offset, &tex);
}
# 1359 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(
  T *func,
  enum cudaFuncCache cacheConfig
)
{
  return ::cudaFuncSetCacheConfig((const void*)func, cacheConfig);
}

template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(
  T *func,
  enum cudaSharedMemConfig config
)
{
  return ::cudaFuncSetSharedMemConfig((const void*)func, config);
}
# 1404 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 1455 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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;
  }
};
# 1524 "/usr/local/cuda/include/cuda_runtime.h"
template<typename UnaryFunction, class T>
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;
}
# 1719 "/usr/local/cuda/include/cuda_runtime.h"
template<typename UnaryFunction, class T>
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);
}
# 1764 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 1823 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
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);
}
# 1874 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaLaunch(
  T *func
)
{
  return ::cudaLaunch((const void*)func);
}
# 1911 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaFuncGetAttributes(
  struct cudaFuncAttributes *attr,
  T *entry
)
{
  return ::cudaFuncGetAttributes(attr, (const void*)entry);
}
# 1953 "/usr/local/cuda/include/cuda_runtime.h"
template<class T>
static __inline__ __attribute__((host)) cudaError_t cudaFuncSetAttribute(
  T *entry,
  enum cudaFuncAttribute attr,
  int value
)
{
  return ::cudaFuncSetAttribute((const void*)entry, attr, value);
}
# 1983 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim>
static __inline__ __attribute__((host)) cudaError_t cudaBindSurfaceToArray(
  const struct surface<T, dim> &surf,
  cudaArray_const_t array,
  const struct cudaChannelFormatDesc &desc
)
{
  return ::cudaBindSurfaceToArray(&surf, array, &desc);
}
# 2012 "/usr/local/cuda/include/cuda_runtime.h"
template<class T, int dim>
static __inline__ __attribute__((host)) cudaError_t cudaBindSurfaceToArray(
  const struct surface<T, dim> &surf,
  cudaArray_const_t array
)
{
  struct cudaChannelFormatDesc desc;
  cudaError_t err = ::cudaGetChannelDesc(&desc, array);

  return err == cudaSuccess ? cudaBindSurfaceToArray(surf, array, desc) : err;
}
# 2033 "/usr/local/cuda/include/cuda_runtime.h"
#pragma GCC diagnostic pop
# 1 "<command-line>" 2
# 1 "./src/maxpool_layer_kernels.cu"

# 1 "/usr/local/cuda/include/curand.h" 1
# 70 "/usr/local/cuda/include/curand.h"
extern "C" {
# 82 "/usr/local/cuda/include/curand.h"
enum curandStatus {
    CURAND_STATUS_SUCCESS = 0,
    CURAND_STATUS_VERSION_MISMATCH = 100,
    CURAND_STATUS_NOT_INITIALIZED = 101,
    CURAND_STATUS_ALLOCATION_FAILED = 102,
    CURAND_STATUS_TYPE_ERROR = 103,
    CURAND_STATUS_OUT_OF_RANGE = 104,
    CURAND_STATUS_LENGTH_NOT_MULTIPLE = 105,
    CURAND_STATUS_DOUBLE_PRECISION_REQUIRED = 106,
    CURAND_STATUS_LAUNCH_FAILURE = 201,
    CURAND_STATUS_PREEXISTING_FAILURE = 202,
    CURAND_STATUS_INITIALIZATION_FAILED = 203,
    CURAND_STATUS_ARCH_MISMATCH = 204,
    CURAND_STATUS_INTERNAL_ERROR = 999
};





typedef enum curandStatus curandStatus_t;





enum curandRngType {
    CURAND_RNG_TEST = 0,
    CURAND_RNG_PSEUDO_DEFAULT = 100,
    CURAND_RNG_PSEUDO_XORWOW = 101,
    CURAND_RNG_PSEUDO_MRG32K3A = 121,
    CURAND_RNG_PSEUDO_MTGP32 = 141,
    CURAND_RNG_PSEUDO_MT19937 = 142,
    CURAND_RNG_PSEUDO_PHILOX4_32_10 = 161,
    CURAND_RNG_QUASI_DEFAULT = 200,
    CURAND_RNG_QUASI_SOBOL32 = 201,
    CURAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 202,
    CURAND_RNG_QUASI_SOBOL64 = 203,
    CURAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 204
};





typedef enum curandRngType curandRngType_t;





enum curandOrdering {
    CURAND_ORDERING_PSEUDO_BEST = 100,
    CURAND_ORDERING_PSEUDO_DEFAULT = 101,
    CURAND_ORDERING_PSEUDO_SEEDED = 102,
    CURAND_ORDERING_QUASI_DEFAULT = 201
};





typedef enum curandOrdering curandOrdering_t;





enum curandDirectionVectorSet {
    CURAND_DIRECTION_VECTORS_32_JOEKUO6 = 101,
    CURAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 = 102,
    CURAND_DIRECTION_VECTORS_64_JOEKUO6 = 103,
    CURAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 = 104
};





typedef enum curandDirectionVectorSet curandDirectionVectorSet_t;






typedef unsigned int curandDirectionVectors32_t[32];






typedef unsigned long long curandDirectionVectors64_t[64];





struct curandGenerator_st;





typedef struct curandGenerator_st *curandGenerator_t;






typedef double curandDistribution_st;
typedef curandDistribution_st *curandDistribution_t;
typedef struct curandDistributionShift_st *curandDistributionShift_t;





typedef struct curandDistributionM2Shift_st *curandDistributionM2Shift_t;
typedef struct curandHistogramM2_st *curandHistogramM2_t;
typedef unsigned int curandHistogramM2K_st;
typedef curandHistogramM2K_st *curandHistogramM2K_t;
typedef curandDistribution_st curandHistogramM2V_st;
typedef curandHistogramM2V_st *curandHistogramM2V_t;

typedef struct curandDiscreteDistribution_st *curandDiscreteDistribution_t;






enum curandMethod {
    CURAND_CHOOSE_BEST = 0,
    CURAND_ITR = 1,
    CURAND_KNUTH = 2,
    CURAND_HITR = 3,
    CURAND_M1 = 4,
    CURAND_M2 = 5,
    CURAND_BINARY_SEARCH = 6,
    CURAND_DISCRETE_GAUSS = 7,
    CURAND_REJECTION = 8,
    CURAND_DEVICE_API = 9,
    CURAND_FAST_REJECTION = 10,
    CURAND_3RD = 11,
    CURAND_DEFINITION = 12,
    CURAND_POISSON = 13
};

typedef enum curandMethod curandMethod_t;
# 321 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandCreateGenerator(curandGenerator_t *generator, curandRngType_t rng_type);
# 401 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandCreateGeneratorHost(curandGenerator_t *generator, curandRngType_t rng_type);
# 415 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandDestroyGenerator(curandGenerator_t generator);
# 431 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGetVersion(int *version);
# 447 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGetProperty(libraryPropertyType type, int *value);
# 464 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandSetStream(curandGenerator_t generator, cudaStream_t stream);
# 483 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandSetPseudoRandomGeneratorSeed(curandGenerator_t generator, unsigned long long seed);
# 501 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandSetGeneratorOffset(curandGenerator_t generator, unsigned long long offset);
# 525 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandSetGeneratorOrdering(curandGenerator_t generator, curandOrdering_t order);
# 545 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandSetQuasiRandomGeneratorDimensions(curandGenerator_t generator, unsigned int num_dimensions);
# 574 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerate(curandGenerator_t generator, unsigned int *outputPtr, size_t num);
# 602 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateLongLong(curandGenerator_t generator, unsigned long long *outputPtr, size_t num);
# 630 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateUniform(curandGenerator_t generator, float *outputPtr, size_t num);
# 659 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateUniformDouble(curandGenerator_t generator, double *outputPtr, size_t num);
# 704 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateNormal(curandGenerator_t generator, float *outputPtr,
                     size_t n, float mean, float stddev);
# 751 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateNormalDouble(curandGenerator_t generator, double *outputPtr,
                     size_t n, double mean, double stddev);
# 798 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateLogNormal(curandGenerator_t generator, float *outputPtr,
                     size_t n, float mean, float stddev);
# 846 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateLogNormalDouble(curandGenerator_t generator, double *outputPtr,
                     size_t n, double mean, double stddev);
# 872 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandCreatePoissonDistribution(double lambda, curandDiscreteDistribution_t *discrete_distribution);
# 888 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandDestroyDistribution(curandDiscreteDistribution_t discrete_distribution);
# 920 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGeneratePoisson(curandGenerator_t generator, unsigned int *outputPtr,
                     size_t n, double lambda);

curandStatus_t
curandGeneratePoissonMethod(curandGenerator_t generator, unsigned int *outputPtr,
                     size_t n, double lambda, curandMethod_t method);


curandStatus_t
curandGenerateBinomial(curandGenerator_t generator, unsigned int *outputPtr,
                       size_t num, unsigned int n, double p);

curandStatus_t
curandGenerateBinomialMethod(curandGenerator_t generator,
                             unsigned int *outputPtr,
                             size_t num, unsigned int n, double p,
                             curandMethod_t method);
# 958 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGenerateSeeds(curandGenerator_t generator);
# 982 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGetDirectionVectors32(curandDirectionVectors32_t *vectors[], curandDirectionVectorSet_t set);
# 1000 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGetScrambleConstants32(unsigned int * * constants);
# 1024 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGetDirectionVectors64(curandDirectionVectors64_t *vectors[], curandDirectionVectorSet_t set);
# 1042 "/usr/local/cuda/include/curand.h"
curandStatus_t
curandGetScrambleConstants64(unsigned long long * * constants);




}
# 3 "./src/maxpool_layer_kernels.cu" 2
# 1 "/usr/local/cuda/include/cublas_v2.h" 1
# 65 "/usr/local/cuda/include/cublas_v2.h"
# 1 "/usr/local/cuda/include/cublas_api.h" 1
# 73 "/usr/local/cuda/include/cublas_api.h"
# 1 "/usr/local/cuda/include/cuComplex.h" 1
# 62 "/usr/local/cuda/include/cuComplex.h"
extern "C" {




typedef float2 cuFloatComplex;

__attribute__((host)) __attribute__((device)) static __inline__ float cuCrealf (cuFloatComplex x)
{
    return x.x;
}

__attribute__((host)) __attribute__((device)) static __inline__ float cuCimagf (cuFloatComplex x)
{
    return x.y;
}

__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex make_cuFloatComplex
                                                             (float r, float i)
{
    cuFloatComplex res;
    res.x = r;
    res.y = i;
    return res;
}

__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex cuConjf (cuFloatComplex x)
{
    return make_cuFloatComplex (cuCrealf(x), -cuCimagf(x));
}
__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex cuCaddf (cuFloatComplex x,
                                                              cuFloatComplex y)
{
    return make_cuFloatComplex (cuCrealf(x) + cuCrealf(y),
                                cuCimagf(x) + cuCimagf(y));
}

__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex cuCsubf (cuFloatComplex x,
                                                              cuFloatComplex y)
{
        return make_cuFloatComplex (cuCrealf(x) - cuCrealf(y),
                                    cuCimagf(x) - cuCimagf(y));
}






__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex cuCmulf (cuFloatComplex x,
                                                              cuFloatComplex y)
{
    cuFloatComplex prod;
    prod = make_cuFloatComplex ((cuCrealf(x) * cuCrealf(y)) -
                                 (cuCimagf(x) * cuCimagf(y)),
                                 (cuCrealf(x) * cuCimagf(y)) +
                                 (cuCimagf(x) * cuCrealf(y)));
    return prod;
}






__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex cuCdivf (cuFloatComplex x,
                                                              cuFloatComplex y)
{
    cuFloatComplex quot;
    float s = fabsf(cuCrealf(y)) + fabsf(cuCimagf(y));
    float oos = 1.0f / s;
    float ars = cuCrealf(x) * oos;
    float ais = cuCimagf(x) * oos;
    float brs = cuCrealf(y) * oos;
    float bis = cuCimagf(y) * oos;
    s = (brs * brs) + (bis * bis);
    oos = 1.0f / s;
    quot = make_cuFloatComplex (((ars * brs) + (ais * bis)) * oos,
                                ((ais * brs) - (ars * bis)) * oos);
    return quot;
}
# 152 "/usr/local/cuda/include/cuComplex.h"
__attribute__((host)) __attribute__((device)) static __inline__ float cuCabsf (cuFloatComplex x)
{
    float a = cuCrealf(x);
    float b = cuCimagf(x);
    float v, w, t;
    a = fabsf(a);
    b = fabsf(b);
    if (a > b) {
        v = a;
        w = b;
    } else {
        v = b;
        w = a;
    }
    t = w / v;
    t = 1.0f + t * t;
    t = v * sqrtf(t);
    if ((v == 0.0f) || (v > 3.402823466e38f) || (w > 3.402823466e38f)) {
        t = v + w;
    }
    return t;
}


typedef double2 cuDoubleComplex;

__attribute__((host)) __attribute__((device)) static __inline__ double cuCreal (cuDoubleComplex x)
{
    return x.x;
}

__attribute__((host)) __attribute__((device)) static __inline__ double cuCimag (cuDoubleComplex x)
{
    return x.y;
}

__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex make_cuDoubleComplex
                                                           (double r, double i)
{
    cuDoubleComplex res;
    res.x = r;
    res.y = i;
    return res;
}

__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuConj(cuDoubleComplex x)
{
    return make_cuDoubleComplex (cuCreal(x), -cuCimag(x));
}

__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuCadd(cuDoubleComplex x,
                                                             cuDoubleComplex y)
{
    return make_cuDoubleComplex (cuCreal(x) + cuCreal(y),
                                 cuCimag(x) + cuCimag(y));
}

__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuCsub(cuDoubleComplex x,
                                                             cuDoubleComplex y)
{
    return make_cuDoubleComplex (cuCreal(x) - cuCreal(y),
                                 cuCimag(x) - cuCimag(y));
}






__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuCmul(cuDoubleComplex x,
                                                             cuDoubleComplex y)
{
    cuDoubleComplex prod;
    prod = make_cuDoubleComplex ((cuCreal(x) * cuCreal(y)) -
                                 (cuCimag(x) * cuCimag(y)),
                                 (cuCreal(x) * cuCimag(y)) +
                                 (cuCimag(x) * cuCreal(y)));
    return prod;
}






__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuCdiv(cuDoubleComplex x,
                                                             cuDoubleComplex y)
{
    cuDoubleComplex quot;
    double s = (fabs(cuCreal(y))) + (fabs(cuCimag(y)));
    double oos = 1.0 / s;
    double ars = cuCreal(x) * oos;
    double ais = cuCimag(x) * oos;
    double brs = cuCreal(y) * oos;
    double bis = cuCimag(y) * oos;
    s = (brs * brs) + (bis * bis);
    oos = 1.0 / s;
    quot = make_cuDoubleComplex (((ars * brs) + (ais * bis)) * oos,
                                 ((ais * brs) - (ars * bis)) * oos);
    return quot;
}







__attribute__((host)) __attribute__((device)) static __inline__ double cuCabs (cuDoubleComplex x)
{
    double a = cuCreal(x);
    double b = cuCimag(x);
    double v, w, t;
    a = fabs(a);
    b = fabs(b);
    if (a > b) {
        v = a;
        w = b;
    } else {
        v = b;
        w = a;
    }
    t = w / v;
    t = 1.0 + t * t;
    t = v * sqrt(t);
    if ((v == 0.0) ||
        (v > 1.79769313486231570e+308) || (w > 1.79769313486231570e+308)) {
        t = v + w;
    }
    return t;
}


}



typedef cuFloatComplex cuComplex;
__attribute__((host)) __attribute__((device)) static __inline__ cuComplex make_cuComplex (float x,
                                                                float y)
{
    return make_cuFloatComplex (x, y);
}


__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuComplexFloatToDouble
                                                      (cuFloatComplex c)
{
    return make_cuDoubleComplex ((double)cuCrealf(c), (double)cuCimagf(c));
}

__attribute__((host)) __attribute__((device)) static __inline__ cuFloatComplex cuComplexDoubleToFloat
(cuDoubleComplex c)
{
 return make_cuFloatComplex ((float)cuCreal(c), (float)cuCimag(c));
}


__attribute__((host)) __attribute__((device)) static __inline__ cuComplex cuCfmaf( cuComplex x, cuComplex y, cuComplex d)
{
    float real_res;
    float imag_res;

    real_res = (cuCrealf(x) * cuCrealf(y)) + cuCrealf(d);
    imag_res = (cuCrealf(x) * cuCimagf(y)) + cuCimagf(d);

    real_res = -(cuCimagf(x) * cuCimagf(y)) + real_res;
    imag_res = (cuCimagf(x) * cuCrealf(y)) + imag_res;

    return make_cuComplex(real_res, imag_res);
}

__attribute__((host)) __attribute__((device)) static __inline__ cuDoubleComplex cuCfma( cuDoubleComplex x, cuDoubleComplex y, cuDoubleComplex d)
{
    double real_res;
    double imag_res;

    real_res = (cuCreal(x) * cuCreal(y)) + cuCreal(d);
    imag_res = (cuCreal(x) * cuCimag(y)) + cuCimag(d);

    real_res = -(cuCimag(x) * cuCimag(y)) + real_res;
    imag_res = (cuCimag(x) * cuCreal(y)) + imag_res;

    return make_cuDoubleComplex(real_res, imag_res);
}
# 74 "/usr/local/cuda/include/cublas_api.h" 2

# 1 "/usr/local/cuda/include/cuda_fp16.h" 1
# 106 "/usr/local/cuda/include/cuda_fp16.h"
struct __half;
struct __half2;


static __inline__ __attribute__((host)) __attribute__((device)) float2 make_float2(float x, float y);
# 123 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __float2half(const float a);
# 133 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __float2half_rn(const float a);
# 143 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __float2half_rz(const float a);
# 153 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __float2half_rd(const float a);
# 163 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __float2half_ru(const float a);
# 172 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ float __half2float(const __half a);
# 183 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ int __half2int_rn(__half h);
# 193 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ int __half2int_rz(__half h);
# 203 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ int __half2int_rd(__half h);
# 213 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ int __half2int_ru(__half h);
# 224 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __int2half_rn(int i);
# 234 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __int2half_rz(int i);
# 244 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __int2half_rd(int i);
# 254 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __int2half_ru(int i);
# 266 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ short int __half2short_rn(__half h);
# 276 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ short int __half2short_rz(__half h);
# 286 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ short int __half2short_rd(__half h);
# 296 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ short int __half2short_ru(__half h);
# 308 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __short2half_rn(short int i);
# 318 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __short2half_rz(short int i);
# 328 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __short2half_rd(short int i);
# 338 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __short2half_ru(short int i);
# 349 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned int __half2uint_rn(__half h);
# 359 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned int __half2uint_rz(__half h);
# 369 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned int __half2uint_rd(__half h);
# 379 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned int __half2uint_ru(__half h);
# 390 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __uint2half_rn(unsigned int i);
# 400 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __uint2half_rz(unsigned int i);
# 410 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __uint2half_rd(unsigned int i);
# 420 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __uint2half_ru(unsigned int i);
# 432 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned short int __half2ushort_rn(__half h);
# 443 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned short int __half2ushort_rz(__half h);
# 453 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned short int __half2ushort_rd(__half h);
# 463 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned short int __half2ushort_ru(__half h);
# 475 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ushort2half_rn(unsigned short int i);
# 486 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ushort2half_rz(unsigned short int i);
# 496 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ushort2half_rd(unsigned short int i);
# 506 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ushort2half_ru(unsigned short int i);
# 518 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned long long int __half2ull_rn(__half h);
# 529 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned long long int __half2ull_rz(__half h);
# 539 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned long long int __half2ull_rd(__half h);
# 549 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned long long int __half2ull_ru(__half h);
# 561 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ull2half_rn(unsigned long long int i);
# 572 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ull2half_rz(unsigned long long int i);
# 582 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ull2half_rd(unsigned long long int i);
# 592 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ull2half_ru(unsigned long long int i);
# 604 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ long long int __half2ll_rn(__half h);
# 614 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ long long int __half2ll_rz(__half h);
# 624 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ long long int __half2ll_rd(__half h);
# 634 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ long long int __half2ll_ru(__half h);
# 646 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ll2half_rn(long long int i);
# 656 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ll2half_rz(long long int i);
# 666 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ll2half_rd(long long int i);
# 676 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ll2half_ru(long long int i);
# 687 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half htrunc(const __half h);
# 696 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hceil(const __half h);
# 705 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hfloor(const __half h);
# 717 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hrint(const __half h);
# 728 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2trunc(const __half2 h);
# 739 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2ceil(const __half2 h);
# 750 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2floor(const __half2 h);
# 763 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2rint(const __half2 h);
# 776 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __float2half2_rn(const float a);
# 790 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __floats2half2_rn(const float a, const float b);
# 804 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __float22half2_rn(const float2 a);
# 814 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ float2 __half22float2(const __half2 a);
# 824 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ float __low2float(const __half2 a);
# 834 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __half2half2(const __half a);
# 844 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ float __high2float(const __half2 a);
# 854 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __lowhigh2highlow(const __half2 a);
# 867 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __lows2half2(const __half2 a, const __half2 b);
# 880 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __highs2half2(const __half2 a, const __half2 b);
# 889 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __high2half(const __half2 a);
# 898 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __low2half(const __half2 a);
# 908 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ int __hisinf(const __half a);
# 920 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __halves2half2(const __half a, const __half b);
# 931 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __low2half2(const __half2 a);
# 942 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __high2half2(const __half2 a);
# 953 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ short int __half_as_short(const __half h);
# 963 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ unsigned short int __half_as_ushort(const __half h);
# 973 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __short_as_half(const short int i);
# 983 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __ushort_as_half(const unsigned short int i);
# 1006 "/usr/local/cuda/include/cuda_fp16.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)."))) __half2 __shfl(__half2 var, 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)."))) __half2 __shfl_up(__half2 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).")))__half2 __shfl_down(__half2 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)."))) __half2 __shfl_xor(__half2 var, int delta, 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)."))) __half __shfl(__half var, 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)."))) __half __shfl_up(__half 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)."))) __half __shfl_down(__half 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)."))) __half __shfl_xor(__half var, int delta, int width = 32);

static __attribute__((device)) __inline__ __half2 __shfl_sync(unsigned mask, __half2 var, int delta, int width = 32);
static __attribute__((device)) __inline__ __half2 __shfl_up_sync(unsigned mask, __half2 var, unsigned int delta, int width = 32);
static __attribute__((device)) __inline__ __half2 __shfl_down_sync(unsigned mask, __half2 var, unsigned int delta, int width = 32);
static __attribute__((device)) __inline__ __half2 __shfl_xor_sync(unsigned mask, __half2 var, int delta, int width = 32);
static __attribute__((device)) __inline__ __half __shfl_sync(unsigned mask, __half var, int delta, int width = 32);
static __attribute__((device)) __inline__ __half __shfl_up_sync(unsigned mask, __half var, unsigned int delta, int width = 32);
static __attribute__((device)) __inline__ __half __shfl_down_sync(unsigned mask, __half var, unsigned int delta, int width = 32);
static __attribute__((device)) __inline__ __half __shfl_xor_sync(unsigned mask, __half var, int delta, int width = 32);
# 1031 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __ldg(const __half2 *ptr);
static __attribute__((device)) __inline__ __half __ldg(const __half *ptr);
static __attribute__((device)) __inline__ __half2 __ldcg(const __half2 *ptr);
static __attribute__((device)) __inline__ __half __ldcg(const __half *ptr);
static __attribute__((device)) __inline__ __half2 __ldca(const __half2 *ptr);
static __attribute__((device)) __inline__ __half __ldca(const __half *ptr);
static __attribute__((device)) __inline__ __half2 __ldcs(const __half2 *ptr);
static __attribute__((device)) __inline__ __half __ldcs(const __half *ptr);
# 1053 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __heq2(const __half2 a, const __half2 b);
# 1065 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hne2(const __half2 a, const __half2 b);
# 1077 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hle2(const __half2 a, const __half2 b);
# 1089 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hge2(const __half2 a, const __half2 b);
# 1101 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hlt2(const __half2 a, const __half2 b);
# 1113 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hgt2(const __half2 a, const __half2 b);
# 1125 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hequ2(const __half2 a, const __half2 b);
# 1137 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hneu2(const __half2 a, const __half2 b);
# 1149 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hleu2(const __half2 a, const __half2 b);
# 1161 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hgeu2(const __half2 a, const __half2 b);
# 1173 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hltu2(const __half2 a, const __half2 b);
# 1185 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hgtu2(const __half2 a, const __half2 b);
# 1195 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hisnan2(const __half2 a);
# 1205 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hadd2(const __half2 a, const __half2 b);
# 1216 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hsub2(const __half2 a, const __half2 b);
# 1227 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hmul2(const __half2 a, const __half2 b);
# 1237 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __h2div(const __half2 a, const __half2 b);
# 1250 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hadd2_sat(const __half2 a, const __half2 b);
# 1263 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hsub2_sat(const __half2 a, const __half2 b);
# 1276 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hmul2_sat(const __half2 a, const __half2 b);
# 1289 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hfma2(const __half2 a, const __half2 b, const __half2 c);
# 1303 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hfma2_sat(const __half2 a, const __half2 b, const __half2 c);
# 1313 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 __hneg2(const __half2 a);
# 1323 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hadd(const __half a, const __half b);
# 1333 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hsub(const __half a, const __half b);
# 1343 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hmul(const __half a, const __half b);
# 1353 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hdiv(const __half a, const __half b);
# 1364 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hadd_sat(const __half a, const __half b);
# 1377 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hsub_sat(const __half a, const __half b);
# 1390 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hmul_sat(const __half a, const __half b);
# 1402 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hfma(const __half a, const __half b, const __half c);
# 1416 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hfma_sat(const __half a, const __half b, const __half c);
# 1425 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half __hneg(const __half a);
# 1439 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbeq2(const __half2 a, const __half2 b);
# 1453 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbne2(const __half2 a, const __half2 b);
# 1467 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hble2(const __half2 a, const __half2 b);
# 1481 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbge2(const __half2 a, const __half2 b);
# 1495 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hblt2(const __half2 a, const __half2 b);
# 1509 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbgt2(const __half2 a, const __half2 b);
# 1523 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbequ2(const __half2 a, const __half2 b);
# 1537 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbneu2(const __half2 a, const __half2 b);
# 1551 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbleu2(const __half2 a, const __half2 b);
# 1567 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbgeu2(const __half2 a, const __half2 b);
# 1581 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbltu2(const __half2 a, const __half2 b);
# 1597 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hbgtu2(const __half2 a, const __half2 b);
# 1607 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __heq(const __half a, const __half b);
# 1617 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hne(const __half a, const __half b);
# 1627 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hle(const __half a, const __half b);
# 1637 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hge(const __half a, const __half b);
# 1647 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hlt(const __half a, const __half b);
# 1657 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hgt(const __half a, const __half b);
# 1668 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hequ(const __half a, const __half b);
# 1679 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hneu(const __half a, const __half b);
# 1690 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hleu(const __half a, const __half b);
# 1701 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hgeu(const __half a, const __half b);
# 1712 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hltu(const __half a, const __half b);
# 1723 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hgtu(const __half a, const __half b);
# 1732 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ bool __hisnan(const __half a);
# 1741 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hsqrt(const __half a);
# 1752 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hrsqrt(const __half a);
# 1761 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hrcp(const __half a);
# 1771 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hlog(const __half a);
# 1781 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hlog2(const __half a);
# 1791 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hlog10(const __half a);
# 1802 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hexp(const __half a);
# 1813 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hexp2(const __half a);
# 1824 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hexp10(const __half a);
# 1833 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hcos(const __half a);
# 1842 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half hsin(const __half a);
# 1852 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2sqrt(const __half2 a);
# 1863 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2rsqrt(const __half2 a);
# 1873 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2rcp(const __half2 a);
# 1884 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2log(const __half2 a);
# 1895 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2log2(const __half2 a);
# 1906 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2log10(const __half2 a);
# 1917 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2exp(const __half2 a);
# 1928 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2exp2(const __half2 a);
# 1939 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2exp10(const __half2 a);
# 1949 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2cos(const __half2 a);
# 1958 "/usr/local/cuda/include/cuda_fp16.h"
static __attribute__((device)) __inline__ __half2 h2sin(const __half2 a);
# 1967 "/usr/local/cuda/include/cuda_fp16.h"
# 1 "/usr/local/cuda/include/cuda_fp16.hpp" 1
# 104 "/usr/local/cuda/include/cuda_fp16.hpp"
typedef struct __attribute__((aligned(2))) {
    unsigned short x;
} __half_raw;

typedef struct __attribute__((aligned(4))) {
    unsigned short x, y;
} __half2_raw;







#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#pragma GCC diagnostic ignored "-Weffc++"



struct __attribute__((aligned(2))) __half {
protected:
    unsigned short __x;

public:



    __attribute__((host)) __attribute__((device)) __half() { }



    __attribute__((host)) __attribute__((device)) __half(const __half_raw &hr) : __x(hr.x) { }
    __attribute__((host)) __attribute__((device)) __half &operator=(const __half_raw &hr) { __x = hr.x; return *this; }
    __attribute__((host)) __attribute__((device)) operator __half_raw() const { __half_raw ret; ret.x = __x; return ret; }






    __attribute__((device)) __half(float f) { __x = __float2half(f).__x; }
    __attribute__((device)) __half(double f) { __x = __float2half((float)f).__x; }
    __attribute__((device)) __half(short val) { __x = __short2half_rn(val).__x; }
    __attribute__((device)) __half(unsigned short val) { __x = __ushort2half_rn(val).__x; }
    __attribute__((device)) __half(int val) { __x = __int2half_rn(val).__x; }
    __attribute__((device)) __half(unsigned int val) { __x = __uint2half_rn(val).__x; }
    __attribute__((device)) __half(long long val) { __x = __ll2half_rn(val).__x; }
    __attribute__((device)) __half(unsigned long long val) { __x = __ull2half_rn(val).__x; }


    __attribute__((device)) operator float() const { return __half2float(*this); }
    __attribute__((device)) __half &operator=(float f) { __x = __float2half(f).__x; return *this; }


    __attribute__((device)) __half &operator=(double f) { __x = __float2half((float)f).__x; return *this; }

    __attribute__((device)) operator short() const { return __half2short_rn(*this); }
    __attribute__((device)) __half &operator=(short val) { __x = __short2half_rn(val).__x; return *this; }

    __attribute__((device)) operator unsigned short() const { return __half2ushort_rn(*this); }
    __attribute__((device)) __half &operator=(unsigned short val) { __x = __ushort2half_rn(val).__x; return *this; }

    __attribute__((device)) operator int() const { return __half2int_rn(*this); }
    __attribute__((device)) __half &operator=(int val) { __x = __int2half_rn(val).__x; return *this; }

    __attribute__((device)) operator unsigned int() const { return __half2uint_rn(*this); }
    __attribute__((device)) __half &operator=(unsigned int val) { __x = __uint2half_rn(val).__x; return *this; }

    __attribute__((device)) operator long long() const { return __half2ll_rn(*this); }
    __attribute__((device)) __half &operator=(long long val) { __x = __ll2half_rn(val).__x; return *this; }

    __attribute__((device)) operator unsigned long long() const { return __half2ull_rn(*this); }
    __attribute__((device)) __half &operator=(unsigned long long val) { __x = __ull2half_rn(val).__x; return *this; }


    __attribute__((device)) operator bool() const { return (__x & 0x7FFF) != 0; }


};
# 192 "/usr/local/cuda/include/cuda_fp16.hpp"
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator+(const __half &lh, const __half &rh) { return __hadd(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator-(const __half &lh, const __half &rh) { return __hsub(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator*(const __half &lh, const __half &rh) { return __hmul(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator/(const __half &lh, const __half &rh) { return __hdiv(lh, rh); }

__attribute__((device)) __inline__ __attribute__((always_inline)) __half &operator+=(__half &lh, const __half &rh) { lh = __hadd(lh, rh); return lh; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half &operator-=(__half &lh, const __half &rh) { lh = __hsub(lh, rh); return lh; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half &operator*=(__half &lh, const __half &rh) { lh = __hmul(lh, rh); return lh; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half &operator/=(__half &lh, const __half &rh) { lh = __hdiv(lh, rh); return lh; }


__attribute__((device)) __inline__ __attribute__((always_inline)) __half &operator++(__half &h) { __half_raw one; one.x = 0x3C00; h += one; return h; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half &operator--(__half &h) { __half_raw one; one.x = 0x3C00; h -= one; return h; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator++(__half &h, int) { __half ret = h; __half_raw one; one.x = 0x3C00; h += one; return ret; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator--(__half &h, int) { __half ret = h; __half_raw one; one.x = 0x3C00; h -= one; return ret; }


__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator+(const __half &h) { return h; }
__attribute__((device)) __inline__ __attribute__((always_inline)) __half operator-(const __half &h) { return __hneg(h); }


__attribute__((device)) __inline__ __attribute__((always_inline)) bool operator==(const __half &lh, const __half &rh) { return __heq(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) bool operator!=(const __half &lh, const __half &rh) { return __hne(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) bool operator> (const __half &lh, const __half &rh) { return __hgt(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) bool operator< (const __half &lh, const __half &rh) { return __hlt(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) bool operator>=(const __half &lh, const __half &rh) { return __hge(lh, rh); }
__attribute__((device)) __inline__ __attribute__((always_inline)) bool operator<=(const __half &lh, const __half &rh) { return __hle(lh, rh); }





struct __attribute__((aligned(4))) __half2 {
    __half x, y;


public:





    __attribute__((host)) __attribute__((device)) __half2() { }

    __attribute__((host)) __attribute__((device)) __half2(const __half &a, const __half &b) : x(a), y(b) { }
    __attribute__((host)) __attribute__((device)) __half2(const __half2 &src) { *(reinterpret_cast<unsigned int *>(&(*this))) = *(reinterpret_cast<const unsigned int *>(&(src))); }
    __attribute__((host)) __attribute__((device)) __half2 &operator=(const __half2 &src) { *(reinterpret_cast<unsigned int *>(&(*this))) = *(reinterpret_cast<const unsigned int *>(&(src))); return *this; }


    __attribute__((host)) __attribute__((device)) __half2(const __half2_raw &h2r ) { *(reinterpret_cast<unsigned int *>(&(*this))) = *(reinterpret_cast<const unsigned int *>(&(h2r))); }
    __attribute__((host)) __attribute__((device)) __half2 &operator=(const __half2_raw &h2r) { *(reinterpret_cast<unsigned int *>(&(*this))) = *(reinterpret_cast<const unsigned int *>(&(h2r))); return *this; }
    __attribute__((host)) __attribute__((device)) operator __half2_raw() const { __half2_raw ret; *(reinterpret_cast<unsigned int *>(&(ret))) = *(reinterpret_cast<const unsigned int *>(&(*this))); return ret; }
};




#pragma GCC diagnostic pop
# 260 "/usr/local/cuda/include/cuda_fp16.hpp"
static __inline__ __attribute__((host)) __attribute__((device)) __half2 make_half2(__half x, __half y)
{
    __half2 t; t.x = x; t.y = y; return t;
}




static __attribute__((device)) __inline__ int __half2int_rn(__half h)
{
    int i;
    asm("cvt.rni.s32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ int __half2int_rz(__half h)
{
    int i;
    asm("cvt.rzi.s32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ int __half2int_rd(__half h)
{
    int i;
    asm("cvt.rmi.s32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ int __half2int_ru(__half h)
{
    int i;
    asm("cvt.rpi.s32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ __half __int2half_rn(int i)
{
    __half h;
    asm("cvt.rn.f16.s32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __int2half_rz(int i)
{
    __half h;
    asm("cvt.rz.f16.s32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __int2half_rd(int i)
{
    __half h;
    asm("cvt.rm.f16.s32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __int2half_ru(int i)
{
    __half h;
    asm("cvt.rp.f16.s32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}

static __attribute__((device)) __inline__ short int __half2short_rn(__half h)
{
    short int i;
    asm("cvt.rni.s16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ short int __half2short_rz(__half h)
{
    short int i;
    asm("cvt.rzi.s16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ short int __half2short_rd(__half h)
{
    short int i;
    asm("cvt.rmi.s16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ short int __half2short_ru(__half h)
{
    short int i;
    asm("cvt.rpi.s16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ __half __short2half_rn(short int i)
{
    __half h;
    asm("cvt.rn.f16.s16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __short2half_rz(short int i)
{
    __half h;
    asm("cvt.rz.f16.s16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __short2half_rd(short int i)
{
    __half h;
    asm("cvt.rm.f16.s16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __short2half_ru(short int i)
{
    __half h;
    asm("cvt.rp.f16.s16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}

static __attribute__((device)) __inline__ unsigned int __half2uint_rn(__half h)
{
    unsigned int i;
    asm("cvt.rni.u32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned int __half2uint_rz(__half h)
{
    unsigned int i;
    asm("cvt.rzi.u32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned int __half2uint_rd(__half h)
{
    unsigned int i;
    asm("cvt.rmi.u32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned int __half2uint_ru(__half h)
{
    unsigned int i;
    asm("cvt.rpi.u32.f16 %0, %1;" : "=r"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ __half __uint2half_rn(unsigned int i)
{
    __half h;
    asm("cvt.rn.f16.u32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __uint2half_rz(unsigned int i)
{
    __half h;
    asm("cvt.rz.f16.u32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __uint2half_rd(unsigned int i)
{
    __half h;
    asm("cvt.rm.f16.u32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __uint2half_ru(unsigned int i)
{
    __half h;
    asm("cvt.rp.f16.u32 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "r"(i));
    return h;
}

static __attribute__((device)) __inline__ unsigned short int __half2ushort_rn(__half h)
{
    unsigned short int i;
    asm("cvt.rni.u16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned short int __half2ushort_rz(__half h)
{
    unsigned short int i;
    asm("cvt.rzi.u16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned short int __half2ushort_rd(__half h)
{
    unsigned short int i;
    asm("cvt.rmi.u16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned short int __half2ushort_ru(__half h)
{
    unsigned short int i;
    asm("cvt.rpi.u16.f16 %0, %1;" : "=h"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ __half __ushort2half_rn(unsigned short int i)
{
    __half h;
    asm("cvt.rn.f16.u16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ushort2half_rz(unsigned short int i)
{
    __half h;
    asm("cvt.rz.f16.u16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ushort2half_rd(unsigned short int i)
{
    __half h;
    asm("cvt.rm.f16.u16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ushort2half_ru(unsigned short int i)
{
    __half h;
    asm("cvt.rp.f16.u16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "h"(i));
    return h;
}

static __attribute__((device)) __inline__ unsigned long long int __half2ull_rn(__half h)
{
    unsigned long long int i;
    asm("cvt.rni.u64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned long long int __half2ull_rz(__half h)
{
    unsigned long long int i;
    asm("cvt.rzi.u64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned long long int __half2ull_rd(__half h)
{
    unsigned long long int i;
    asm("cvt.rmi.u64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ unsigned long long int __half2ull_ru(__half h)
{
    unsigned long long int i;
    asm("cvt.rpi.u64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ __half __ull2half_rn(unsigned long long int i)
{
    __half h;
    asm("cvt.rn.f16.u64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ull2half_rz(unsigned long long int i)
{
    __half h;
    asm("cvt.rz.f16.u64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ull2half_rd(unsigned long long int i)
{
    __half h;
    asm("cvt.rm.f16.u64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ull2half_ru(unsigned long long int i)
{
    __half h;
    asm("cvt.rp.f16.u64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}

static __attribute__((device)) __inline__ long long int __half2ll_rn(__half h)
{
    long long int i;
    asm("cvt.rni.s64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ long long int __half2ll_rz(__half h)
{
    long long int i;
    asm("cvt.rzi.s64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ long long int __half2ll_rd(__half h)
{
    long long int i;
    asm("cvt.rmi.s64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ long long int __half2ll_ru(__half h)
{
    long long int i;
    asm("cvt.rpi.s64.f16 %0, %1;" : "=l"(i) : "h"(*(reinterpret_cast<unsigned short *>(&(h)))));
    return i;
}
static __attribute__((device)) __inline__ __half __ll2half_rn(long long int i)
{
    __half h;
    asm("cvt.rn.f16.s64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ll2half_rz(long long int i)
{
    __half h;
    asm("cvt.rz.f16.s64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ll2half_rd(long long int i)
{
    __half h;
    asm("cvt.rm.f16.s64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}
static __attribute__((device)) __inline__ __half __ll2half_ru(long long int i)
{
    __half h;
    asm("cvt.rp.f16.s64 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(h)))) : "l"(i));
    return h;
}

static __attribute__((device)) __inline__ __half htrunc(const __half h)
{
    __half r;
    asm("cvt.rzi.f16.f16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(h)))));
    return r;
}
static __attribute__((device)) __inline__ __half hceil(const __half h)
{
    __half r;
    asm("cvt.rpi.f16.f16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(h)))));
    return r;
}
static __attribute__((device)) __inline__ __half hfloor(const __half h)
{
    __half r;
    asm("cvt.rmi.f16.f16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(h)))));
    return r;
}
static __attribute__((device)) __inline__ __half hrint(const __half h)
{
    __half r;
    asm("cvt.rni.f16.f16 %0, %1;" : "=h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(h)))));
    return r;
}

static __attribute__((device)) __inline__ __half2 h2trunc(const __half2 h)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  cvt.rzi.f16.f16 low, low;\n"
        "  cvt.rzi.f16.f16 high, high;\n"
        "  mov.b32 %0, {low,high};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2ceil(const __half2 h)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  cvt.rpi.f16.f16 low, low;\n"
        "  cvt.rpi.f16.f16 high, high;\n"
        "  mov.b32 %0, {low,high};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2floor(const __half2 h)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  cvt.rmi.f16.f16 low, low;\n"
        "  cvt.rmi.f16.f16 high, high;\n"
        "  mov.b32 %0, {low,high};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2rint(const __half2 h)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  cvt.rni.f16.f16 low, low;\n"
        "  cvt.rni.f16.f16 high, high;\n"
        "  mov.b32 %0, {low,high};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return val;
}

static __attribute__((device)) __inline__ float2 __half22float2(const __half2 l)
{
    float hi_float;
    float lo_float;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high},%1;\n"
        "  cvt.f32.f16 %0, low;}\n" : "=f"(lo_float) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))));

    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high},%1;\n"
        "  cvt.f32.f16 %0, high;}\n" : "=f"(hi_float) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))));

    return make_float2(lo_float, hi_float);
}
static __attribute__((device)) __inline__ __half __float2half(const float f)
{
    __half val;
    asm("{  cvt.rn.f16.f32 %0, %1;}\n" : "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "f"(f));
    return val;
}
static __attribute__((device)) __inline__ __half __float2half_rn(const float f)
{
    __half val;
    asm("{  cvt.rn.f16.f32 %0, %1;}\n" : "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "f"(f));
    return val;
}
static __attribute__((device)) __inline__ __half __float2half_rz(const float f)
{
    __half val;
    asm("{  cvt.rz.f16.f32 %0, %1;}\n" : "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "f"(f));
    return val;
}
static __attribute__((device)) __inline__ __half __float2half_rd(const float f)
{
    __half val;
    asm("{  cvt.rm.f16.f32 %0, %1;}\n" : "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "f"(f));
    return val;
}
static __attribute__((device)) __inline__ __half __float2half_ru(const float f)
{
    __half val;
    asm("{  cvt.rp.f16.f32 %0, %1;}\n" : "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "f"(f));
    return val;
}
static __attribute__((device)) __inline__ float __half2float(const __half h)
{
    float val;
    asm("{  cvt.f32.f16 %0, %1;}\n" : "=f"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 __float2half2_rn(const float f)
{
    __half2 val;
    asm("{.reg .f16 low;\n"
        "  cvt.rn.f16.f32 low, %1;\n"
        "  mov.b32 %0, {low,low};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "f"(f));
    return val;
}
static __attribute__((device)) __inline__ __half2 __floats2half2_rn(const float f1, const float f2)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  cvt.rn.f16.f32 low, %1;\n"
        "  cvt.rn.f16.f32 high, %2;\n"
        "  mov.b32 %0, {low,high};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "f"(f1), "f"(f2));
    return val;
}
static __attribute__((device)) __inline__ __half2 __float22half2_rn(const float2 f)
{
    __half2 val = __floats2half2_rn(f.x, f.y);
    return val;
}
static __attribute__((device)) __inline__ float __low2float(const __half2 l)
{
    float val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high},%1;\n"
        "  cvt.f32.f16 %0, low;}\n" : "=f"(val) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))));
    return val;
}
static __attribute__((device)) __inline__ float __high2float(const __half2 l)
{
    float val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high},%1;\n"
        "  cvt.f32.f16 %0, high;}\n" : "=f"(val) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 __lows2half2(const __half2 l, const __half2 h)
{
    __half2 val;
    asm("{.reg .f16 alow,ahigh,blow,bhigh;\n"
        "  mov.b32 {alow,ahigh}, %1;\n"
        "  mov.b32 {blow,bhigh}, %2;\n"
        "  mov.b32 %0, {alow,blow};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))), "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 __highs2half2(const __half2 l, const __half2 h)
{
    __half2 val;
    asm("{.reg .f16 alow,ahigh,blow,bhigh;\n"
        "  mov.b32 {alow,ahigh}, %1;\n"
        "  mov.b32 {blow,bhigh}, %2;\n"
        "  mov.b32 %0, {ahigh,bhigh};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))), "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half __low2half(const __half2 h)
{
    __half ret;
    asm("{.reg .f16 low,high;\n"
        " mov.b32 {low,high}, %1;\n"
        " mov.b16 %0, low;}" : "=h"(*(reinterpret_cast<unsigned short *>(&(ret)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return ret;
}
static __attribute__((device)) __inline__ int __hisinf(const __half a)
{
    if (*(reinterpret_cast<const unsigned short *>(&(a))) == 0xFC00)
        return -1;
    if (*(reinterpret_cast<const unsigned short *>(&(a))) == 0x7C00)
        return 1;
    return 0;
}
static __attribute__((device)) __inline__ __half2 __low2half2(const __half2 l)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  mov.b32 %0, {low,low};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 __high2half2(const __half2 l)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  mov.b32 %0, {high,high};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(l)))));
    return val;
}
static __attribute__((device)) __inline__ __half __high2half(const __half2 h)
{
    __half ret;
    asm("{.reg .f16 low,high;\n"
        " mov.b32 {low,high}, %1;\n"
        " mov.b16 %0, high;}" : "=h"(*(reinterpret_cast<unsigned short *>(&(ret)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(h)))));
    return ret;
}
static __attribute__((device)) __inline__ __half2 __halves2half2(const __half l, const __half h)
{
    __half2 val;
    asm("{  mov.b32 %0, {%1,%2};}\n"
        : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(l)))), "h"(*(reinterpret_cast<const unsigned short *>(&(h)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 __half2half2(const __half lh)
{
    __half2 val;
    asm("{  mov.b32 %0, {%1,%1};}\n"
        : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(lh)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 __lowhigh2highlow(const __half2 lh)
{
    __half2 val;
    asm("{.reg .f16 low,high;\n"
        "  mov.b32 {low,high}, %1;\n"
        "  mov.b32 %0, {high,low};}\n" : "=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(lh)))));
    return val;
}
static __attribute__((device)) __inline__ short int __half_as_short(const __half h)
{
    return (short int)*(reinterpret_cast<const unsigned short *>(&(h)));
}
static __attribute__((device)) __inline__ unsigned short int __half_as_ushort(const __half h)
{
    return *(reinterpret_cast<const unsigned short *>(&(h)));
}
static __attribute__((device)) __inline__ __half __short_as_half(const short int i)
{
    __half h;
    *(reinterpret_cast<unsigned short *>(&(h))) = (unsigned short int)i;
    return h;
}
static __attribute__((device)) __inline__ __half __ushort_as_half(const unsigned short int i)
{
    __half h;
    *(reinterpret_cast<unsigned short *>(&(h))) = i;
    return h;
}
# 835 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ __half2 __shfl(__half2 var, int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = ((warpSize - width) << 8) | 0x1f;
    do { __half2 r; asm("{""shfl.idx.b32"" %0,%1,%2,%3;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c)); return r; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __shfl_up(__half2 var, unsigned int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = (warpSize - width) << 8;
    do { __half2 r; asm("{""shfl.up.b32"" %0,%1,%2,%3;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c)); return r; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __shfl_down(__half2 var, unsigned int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = ((warpSize - width) << 8) | 0x1f;
    do { __half2 r; asm("{""shfl.down.b32"" %0,%1,%2,%3;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c)); return r; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __shfl_xor(__half2 var, int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = ((warpSize - width) << 8) | 0x1f;
    do { __half2 r; asm("{""shfl.bfly.b32"" %0,%1,%2,%3;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c)); return r; } while(0);;
}

static __attribute__((device)) __inline__ __half2 __shfl_sync(unsigned mask, __half2 var, int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = ((warpSize - width) << 8) | 0x1f;
    do { __half2 r; asm("{""shfl.sync.idx.b32"" %0,%1,%2,%3,%4;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c), "r"(mask)); return r; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __shfl_up_sync(unsigned mask, __half2 var, unsigned int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = (warpSize - width) << 8;
    do { __half2 r; asm("{""shfl.sync.up.b32"" %0,%1,%2,%3,%4;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c), "r"(mask)); return r; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __shfl_down_sync(unsigned mask, __half2 var, unsigned int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = ((warpSize - width) << 8) | 0x1f;
    do { __half2 r; asm("{""shfl.sync.down.b32"" %0,%1,%2,%3,%4;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c), "r"(mask)); return r; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __shfl_xor_sync(unsigned mask, __half2 var, int delta, int width)
{
    int warpSize;
    asm("{mov.u32 %0, WARP_SZ;\n}" : "=r"(warpSize));
    int c = ((warpSize - width) << 8) | 0x1f;
    do { __half2 r; asm("{""shfl.sync.bfly.b32"" %0,%1,%2,%3,%4;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))): "r"(*(reinterpret_cast<const unsigned int *>(&(var)))), "r"(delta), "r"(c), "r"(mask)); return r; } while(0);;
}




static __attribute__((device)) __inline__ __half __shfl(__half var, int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl(temp1, delta, width);
    return __low2half(temp2);
}
static __attribute__((device)) __inline__ __half __shfl_up(__half var, unsigned int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_up(temp1, delta, width);
    return __low2half(temp2);
}
static __attribute__((device)) __inline__ __half __shfl_down(__half var, unsigned int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_down(temp1, delta, width);
    return __low2half(temp2);
}
static __attribute__((device)) __inline__ __half __shfl_xor(__half var, int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_xor(temp1, delta, width);
    return __low2half(temp2);
}

static __attribute__((device)) __inline__ __half __shfl_sync(unsigned mask, __half var, int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_sync(mask, temp1, delta, width);
    return __low2half(temp2);
}
static __attribute__((device)) __inline__ __half __shfl_up_sync(unsigned mask, __half var, unsigned int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_up_sync(mask, temp1, delta, width);
    return __low2half(temp2);
}
static __attribute__((device)) __inline__ __half __shfl_down_sync(unsigned mask, __half var, unsigned int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_down_sync(mask, temp1, delta, width);
    return __low2half(temp2);
}
static __attribute__((device)) __inline__ __half __shfl_xor_sync(unsigned mask, __half var, int delta, int width)
{
    __half2 temp1 = __halves2half2(var, var);
    __half2 temp2 = __shfl_xor_sync(mask, temp1, delta, width);
    return __low2half(temp2);
}
# 957 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ __half2 __ldg(const __half2 *ptr)
{
    __half2 ret;
    asm ("ld.global.nc.b32 %0, [%1];" : "=r"(*(reinterpret_cast<unsigned int *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half __ldg(const __half *ptr)
{
    __half ret;
    asm ("ld.global.nc.b16 %0, [%1];" : "=h"(*(reinterpret_cast<unsigned short *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half2 __ldcg(const __half2 *ptr)
{
    __half2 ret;
    asm ("ld.global.cg.b32 %0, [%1];" : "=r"(*(reinterpret_cast<unsigned int *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half __ldcg(const __half *ptr)
{
    __half ret;
    asm ("ld.global.cg.b16 %0, [%1];" : "=h"(*(reinterpret_cast<unsigned short *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half2 __ldca(const __half2 *ptr)
{
    __half2 ret;
    asm ("ld.global.ca.b32 %0, [%1];" : "=r"(*(reinterpret_cast<unsigned int *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half __ldca(const __half *ptr)
{
    __half ret;
    asm ("ld.global.ca.b16 %0, [%1];" : "=h"(*(reinterpret_cast<unsigned short *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half2 __ldcs(const __half2 *ptr)
{
    __half2 ret;
    asm ("ld.global.cs.b32 %0, [%1];" : "=r"(*(reinterpret_cast<unsigned int *>(&(ret)))) : "l"(ptr));
    return ret;
}
static __attribute__((device)) __inline__ __half __ldcs(const __half *ptr)
{
    __half ret;
    asm ("ld.global.cs.b16 %0, [%1];" : "=h"(*(reinterpret_cast<unsigned short *>(&(ret)))) : "l"(ptr));
    return ret;
}
# 1017 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ __half2 __heq2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.eq"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hne2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.ne"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hle2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.le"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hge2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.ge"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hlt2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.lt"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hgt2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.gt"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hequ2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.equ"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hneu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.neu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hleu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.leu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hgeu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.geu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hltu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.ltu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hgtu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.gtu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
# 1075 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ bool __hbeq2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.eq"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbne2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.ne"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hble2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.le"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbge2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.ge"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hblt2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.lt"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbgt2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.gt"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbequ2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.equ"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbneu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.neu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbleu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.leu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbgeu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.geu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbltu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.ltu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hbgtu2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{ ""set.gtu"".f16x2.f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); if (*(reinterpret_cast<const unsigned int *>(&(val))) == 0x3C003C00) return true; else return false; } while(0);;
}
# 1135 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ bool __heq(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""eq"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hne(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""ne"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hle(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""le"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hge(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""ge"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hlt(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""lt"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hgt(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""gt"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hequ(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""equ"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hneu(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""neu"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hleu(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""leu"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hgeu(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""geu"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hltu(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""ltu"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
static __attribute__((device)) __inline__ bool __hgtu(const __half a, const __half b)
{
    do { unsigned short val; asm( "{ .reg .pred __$temp3;\n" "  setp.""gtu"".f16  __$temp3, %1, %2;\n" "  selp.u16 %0, 1, 0, __$temp3;}" : "=h"(val) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val ? true : false; } while(0);;
}
# 1194 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ __half2 __hadd2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{""add"".f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hsub2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{""sub"".f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hmul2(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{""mul"".f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hadd2_sat(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{""add.sat"".f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hsub2_sat(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{""sub.sat"".f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hmul2_sat(const __half2 a, const __half2 b)
{
    do { __half2 val; asm( "{""mul.sat"".f16x2 %0,%1,%2;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b))))); return val; } while(0);;
}







static __attribute__((device)) __inline__ __half2 __hfma2(const __half2 a, const __half2 b, const __half2 c)
{
    do { __half2 val; asm( "{""fma.rn"".f16x2 %0,%1,%2,%3;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b)))),"r"(*(reinterpret_cast<const unsigned int *>(&(c))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half2 __hfma2_sat(const __half2 a, const __half2 b, const __half2 c)
{
    do { __half2 val; asm( "{""fma.rn.sat"".f16x2 %0,%1,%2,%3;\n}" :"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))),"r"(*(reinterpret_cast<const unsigned int *>(&(b)))),"r"(*(reinterpret_cast<const unsigned int *>(&(c))))); return val; } while(0);;
}

static __attribute__((device)) __inline__ __half2 __h2div(__half2 a, __half2 b) {
    __half ha, hb;

    ha = __low2half(a);
    hb = __low2half(b);

    __half v1 = __hdiv(ha, hb);

    ha = __high2half(a);
    hb = __high2half(b);

    __half v2 = __hdiv(ha, hb);

    return __halves2half2(v1, v2);
}
# 1258 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ __half __hadd(const __half a, const __half b)
{
    do { __half val; asm( "{""add"".f16 %0,%1,%2;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half __hsub(const __half a, const __half b)
{
    do { __half val; asm( "{""sub"".f16 %0,%1,%2;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half __hmul(const __half a, const __half b)
{
    do { __half val; asm( "{""mul"".f16 %0,%1,%2;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half __hadd_sat(const __half a, const __half b)
{
    do { __half val; asm( "{""add.sat"".f16 %0,%1,%2;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half __hsub_sat(const __half a, const __half b)
{
    do { __half val; asm( "{""sub.sat"".f16 %0,%1,%2;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half __hmul_sat(const __half a, const __half b)
{
    do { __half val; asm( "{""mul.sat"".f16 %0,%1,%2;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b))))); return val; } while(0);;
}







static __attribute__((device)) __inline__ __half __hfma(const __half a, const __half b, const __half c)
{
    do { __half val; asm( "{""fma.rn"".f16 %0,%1,%2,%3;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b)))),"h"(*(reinterpret_cast<const unsigned short *>(&(c))))); return val; } while(0);;
}
static __attribute__((device)) __inline__ __half __hfma_sat(const __half a, const __half b, const __half c)
{
    do { __half val; asm( "{""fma.rn.sat"".f16 %0,%1,%2,%3;\n}" :"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))),"h"(*(reinterpret_cast<const unsigned short *>(&(b)))),"h"(*(reinterpret_cast<const unsigned short *>(&(c))))); return val; } while(0);;
}

static __attribute__((device)) __inline__ __half __hdiv(__half a, __half b) {
    __half v, abs, den;
    *(reinterpret_cast<unsigned short *>(&(den))) = 0x008F;
    float fa, fb, fv, rcp;

    fa = __half2float(a);
    fb = __half2float(b);

    asm("{rcp.approx.f32 %0, %1;\n}" :"=f"(rcp) : "f"(fb));

    fv = rcp * fa;

    v = __float2half(fv);
    *(reinterpret_cast<unsigned short *>(&(abs))) = (unsigned short)(((unsigned int)*(reinterpret_cast<const unsigned short *>(&(v)))) & 0x00007FFF);
    if (__hlt(abs, den) && (!(*(reinterpret_cast<const unsigned short *>(&(abs))) == 0x0000))) {
        float err = __fmaf_rn(-fb, fv, fa);
        fv = __fmaf_rn(rcp, err, fv);
        v = __float2half(fv);
    }
    return v;
}
# 1362 "/usr/local/cuda/include/cuda_fp16.hpp"
static __attribute__((device)) __inline__ __attribute__((always_inline)) float __float_simpl_sinf(float);
static __attribute__((device)) __inline__ __attribute__((always_inline)) float __float_simpl_cosf(float);
static __attribute__((device)) __inline__ __half __hsin_internal(const __half a) {
    float f = __half2float(a);
    f = __float_simpl_sinf(f);
    return __float2half_rn(f);
}
static __attribute__((device)) __inline__ __half hsin(const __half a) {
    __half r = __hsin_internal(a);
    asm("{\n\t"
        "  .reg.b16 i,r,t;     \n\t"
        "  mov.b16 r, %0;      \n\t"
        "  mov.b16 i, %1;      \n\t"
        "  mov.b16 t, 0x8000;  \n\t"
        "  and.b16 t,r,t;      \n\t"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X32B3"";\n" "  mov.b16 ulp,""0x0800"";\n" "  set.eq.f16.f16 p,""i"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X5CB0"";\n" "  mov.b16 ulp,""0x1000"";\n" "  set.eq.f16.f16 p,""i"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0XB2B3"";\n" "  mov.b16 ulp,""0x8800"";\n" "  set.eq.f16.f16 p,""i"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0XDCB0"";\n" "  mov.b16 ulp,""0x9000"";\n" "  set.eq.f16.f16 p,""i"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  or.b16  r,r,t;      \n\t"
        "  mov.b16 %0, r;      \n"
        "}\n" : "+h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return r;
}
static __attribute__((device)) __inline__ __half2 h2sin(const __half2 a) {
    __half l = __low2half(a);
    __half h = __high2half(a);
    __half2 r = __halves2half2(__hsin_internal(l), __hsin_internal(h));
    asm("{\n\t"
        "  .reg.b32 i,r,t;             \n\t"
        "  mov.b32 r, %0;              \n\t"
        "  mov.b32 i, %1;              \n\t"
        "  and.b32 t, r, 0x80008000;   \n\t"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X32B332B3"";\n" "  mov.b32 ulp,""0x08000800"";\n" "  set.eq.f16x2.f16x2 p,""i"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X5CB05CB0"";\n" "  mov.b32 ulp,""0x10001000"";\n" "  set.eq.f16x2.f16x2 p,""i"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0XB2B3B2B3"";\n" "  mov.b32 ulp,""0x88008800"";\n" "  set.eq.f16x2.f16x2 p,""i"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0XDCB0DCB0"";\n" "  mov.b32 ulp,""0x90009000"";\n" "  set.eq.f16x2.f16x2 p,""i"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  or.b32  r, r, t;            \n\t"
        "  mov.b32 %0, r;              \n"
        "}\n" : "+r"(*(reinterpret_cast<unsigned int *>(&(r)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return r;
}
static __attribute__((device)) __inline__ __half __hcos_internal(const __half a) {
    float f = __half2float(a);
    f = __float_simpl_cosf(f);
    return __float2half_rn(f);
}
static __attribute__((device)) __inline__ __half hcos(const __half a) {
    __half r = __hcos_internal(a);
    asm("{\n\t"
        "  .reg.b16 i,r;        \n\t"
        "  mov.b16 r, %0;       \n\t"
        "  mov.b16 i, %1;       \n\t"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X2B7C"";\n" "  mov.b16 ulp,""0x1000"";\n" "  set.eq.f16.f16 p,""i"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0XAB7C"";\n" "  mov.b16 ulp,""0x1000"";\n" "  set.eq.f16.f16 p,""i"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b16 %0, r;       \n"
        "}\n" : "+h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return r;
}
static __attribute__((device)) __inline__ __half2 h2cos(const __half2 a) {
    __half l = __low2half(a);
    __half h = __high2half(a);
    __half2 r = __halves2half2(__hcos_internal(l), __hcos_internal(h));
    asm("{\n\t"
        "  .reg.b32 i,r;   \n\t"
        "  mov.b32 r, %0;  \n\t"
        "  mov.b32 i, %1;  \n\t"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X2B7C2B7C"";\n" "  mov.b32 ulp,""0x10001000"";\n" "  set.eq.f16x2.f16x2 p,""i"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0XAB7CAB7C"";\n" "  mov.b32 ulp,""0x10001000"";\n" "  set.eq.f16x2.f16x2 p,""i"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b32 %0, r;  \n"
        "}\n" : "+r"(*(reinterpret_cast<unsigned int *>(&(r)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return r;
}
static __attribute__((device)) __inline__ __attribute__((always_inline)) float __internal_trig_reduction_kernel(float a, int *quadrant)
{
    float j, t;
    int q;
    q = __float2int_rn(a * 0.636619772f);
    j = (float)q;
    t = __fmaf_rn(-j, 1.5707962512969971e+000f, a);
    t = __fmaf_rn(-j, 7.5497894158615964e-008f, t);
    *quadrant = q;
    return t;
}
static __attribute__((device)) __inline__ __attribute__((always_inline)) float __internal_sin_cos_kernel(float x, int i)
{
    float x2, z;
    x2 = x*x;

    if (i & 1) {
        z = 2.44331571e-5f;
        z = __fmaf_rn(z, x2, -1.38873163e-3f);
    }
    else {
        z = -1.95152959e-4f;
        z = __fmaf_rn(z, x2, 8.33216087e-3f);
    }
    if (i & 1) {
        z = __fmaf_rn(z, x2, 4.16666457e-2f);
        z = __fmaf_rn(z, x2, -5.00000000e-1f);
    }
    else {
        z = __fmaf_rn(z, x2, -1.66666546e-1f);
        z = __fmaf_rn(z, x2, 0.0f);
    }
    x = __fmaf_rn(z, x, x);
    if (i & 1) x = __fmaf_rn(z, x2, 1.0f);
    if (i & 2) x = __fmaf_rn(x, -1.0f, 0.0f);
    return x;
}
static __attribute__((device)) __inline__ __attribute__((always_inline)) float __float_simpl_sinf(float a)
{
    float z;
    int i;
    if (isinf(a)) {
        a = a * 0.0f;
    }
    a = __internal_trig_reduction_kernel(a, &i);
    z = __internal_sin_cos_kernel(a, i);
    return z;
}
static __attribute__((device)) __inline__ __attribute__((always_inline)) float __float_simpl_cosf(float a)
{
    float z;
    int i;
    if (isinf(a)) {
        a = a * 0.0f;
    }
    a = __internal_trig_reduction_kernel(a, &i);
    i++;
    z = __internal_sin_cos_kernel(a, i);
    return z;
}
static __attribute__((device)) __inline__ __half hexp(const __half a) {
    __half val;
    asm("{.reg.b32         f, C;           \n"
        " .reg.b16         h,r;            \n"
        "  mov.b16         h,%1;           \n"
        "  cvt.f32.f16     f,h;            \n"
        "  mov.b32         C, 0x3fb8aa3b;  \n"
        "  mul.f32         f,f,C;          \n"
        "  ex2.approx.f32      f,f;        \n"
        "  cvt.rn.f16.f32      r,f;        \n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X1F79"";\n" "  mov.b16 ulp,""0x9400"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X25CF"";\n" "  mov.b16 ulp,""0x9400"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0XC13B"";\n" "  mov.b16 ulp,""0x0400"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0XC1EF"";\n" "  mov.b16 ulp,""0x0200"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b16         %0,r;           \n"
        "}": "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2exp(const __half2 a) {
    __half2 val;
    asm("{.reg.b16         hl, hu;         \n"
        " .reg.b32         h,r,fl,fu, C;   \n"
        "  mov.b32         {hl, hu}, %1;   \n"
        "  mov.b32         h, %1;          \n"
        "  cvt.f32.f16     fl, hl;         \n"
        "  cvt.f32.f16     fu, hu;         \n"
        "  mov.b32         C, 0x3fb8aa3b;  \n"
        "  mul.f32         fl,fl,C;        \n"
        "  mul.f32         fu,fu,C;        \n"
        "  ex2.approx.f32      fl, fl;     \n"
        "  ex2.approx.f32      fu, fu;     \n"
        "  cvt.rn.f16.f32      hl, fl;     \n"
        "  cvt.rn.f16.f32      hu, fu;     \n"
        "  mov.b32         r, {hl, hu};    \n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X1F791F79"";\n" "  mov.b32 ulp,""0x94009400"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X25CF25CF"";\n" "  mov.b32 ulp,""0x94009400"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0XC13BC13B"";\n" "  mov.b32 ulp,""0x04000400"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0XC1EFC1EF"";\n" "  mov.b32 ulp,""0x02000200"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b32         %0, r;  \n"
        "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half hexp2(const __half a) {
    __half val;
    asm("{.reg.b32         f, ULP;         \n"
        " .reg.b16         r;              \n"
        "  mov.b16         r,%1;           \n"
        "  cvt.f32.f16     f,r;            \n"
        "  ex2.approx.f32      f,f;        \n"
        "  mov.b32         ULP, 0x33800000;\n"
        "  fma.rn.f32      f,f,ULP,f;      \n"
        "  cvt.rn.f16.f32      r,f;        \n"
        "  mov.b16         %0,r;           \n"
        "}": "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2exp2(const __half2 a) {
    __half2 val;
    asm("{.reg.b16         hl, hu;         \n"
        " .reg.b32         fl, fu, ULP;    \n"
        "  mov.b32         {hl, hu}, %1;   \n"
        "  cvt.f32.f16     fl, hl;         \n"
        "  cvt.f32.f16     fu, hu;         \n"
        "  ex2.approx.f32      fl, fl;     \n"
        "  ex2.approx.f32      fu, fu;     \n"
        "  mov.b32         ULP, 0x33800000;\n"
        "  fma.rn.f32      fl,fl,ULP,fl;   \n"
        "  fma.rn.f32      fu,fu,ULP,fu;   \n"
        "  cvt.rn.f16.f32      hl, fl;     \n"
        "  cvt.rn.f16.f32      hu, fu;     \n"
        "  mov.b32         %0, {hl, hu};   \n"
        "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half hexp10(const __half a) {
    __half val;
    asm("{.reg.b16         h,r;            \n"
        " .reg.b32         f, C;           \n"
        "  mov.b16         h, %1;          \n"
        "  cvt.f32.f16     f, h;           \n"
        "  mov.b32         C, 0x40549A78;  \n"
        "  mul.f32         f,f,C;          \n"
        "  ex2.approx.f32      f, f;       \n"
        "  cvt.rn.f16.f32      r, f;       \n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x34DE"";\n" "  mov.b16 ulp,""0x9800"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x9766"";\n" "  mov.b16 ulp,""0x9000"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x9972"";\n" "  mov.b16 ulp,""0x1000"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0xA5C4"";\n" "  mov.b16 ulp,""0x1000"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0xBF0A"";\n" "  mov.b16 ulp,""0x8100"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b16         %0, r;          \n"
        "}":"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2exp10(const __half2 a) {
    __half2 val;
    asm("{.reg.b16         hl, hu;         \n"
        " .reg.b32         h,r,fl,fu, C;   \n"
        "  mov.b32         {hl, hu}, %1;   \n"
        "  mov.b32         h, %1;          \n"
        "  cvt.f32.f16     fl, hl;         \n"
        "  cvt.f32.f16     fu, hu;         \n"
        "  mov.b32         C, 0x40549A78;  \n"
        "  mul.f32         fl,fl,C;        \n"
        "  mul.f32         fu,fu,C;        \n"
        "  ex2.approx.f32      fl, fl;     \n"
        "  ex2.approx.f32      fu, fu;     \n"
        "  cvt.rn.f16.f32      hl, fl;     \n"
        "  cvt.rn.f16.f32      hu, fu;     \n"
        "  mov.b32         r, {hl, hu};    \n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x34DE34DE"";\n" "  mov.b32 ulp,""0x98009800"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x97669766"";\n" "  mov.b32 ulp,""0x90009000"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x99729972"";\n" "  mov.b32 ulp,""0x10001000"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0xA5C4A5C4"";\n" "  mov.b32 ulp,""0x10001000"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0xBF0ABF0A"";\n" "  mov.b32 ulp,""0x81008100"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b32         %0, r;  \n"
        "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half hlog2(const __half a) {
    __half val;
    asm("{.reg.b16         h, r;           \n"
        " .reg.b32         f;              \n"
        "  mov.b16         h, %1;          \n"
        "  cvt.f32.f16     f, h;           \n"
        "  lg2.approx.f32      f, f;       \n"
        "  cvt.rn.f16.f32      r, f;       \n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0xA2E2"";\n" "  mov.b16 ulp,""0x8080"";\n" "  set.eq.f16.f16 p,""r"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0xBF46"";\n" "  mov.b16 ulp,""0x9400"";\n" "  set.eq.f16.f16 p,""r"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b16         %0, r;          \n"
        "}":"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2log2(const __half2 a) {
    __half2 val;
    asm("{.reg.b16         hl, hu;         \n"
        " .reg.b32         fl, fu, r, p;   \n"
        "  mov.b32         {hl, hu}, %1;   \n"
        "  cvt.f32.f16     fl, hl;         \n"
        "  cvt.f32.f16     fu, hu;         \n"
        "  lg2.approx.f32      fl, fl;     \n"
        "  lg2.approx.f32      fu, fu;     \n"
        "  cvt.rn.f16.f32      hl, fl;     \n"
        "  cvt.rn.f16.f32      hu, fu;     \n"
        "  mov.b32         r, {hl, hu};    \n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0xA2E2A2E2"";\n" "  mov.b32 ulp,""0x80808080"";\n" "  set.eq.f16x2.f16x2 p,""r"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0xBF46BF46"";\n" "  mov.b32 ulp,""0x94009400"";\n" "  set.eq.f16x2.f16x2 p,""r"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b32         %0, r;          \n"
        "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half hlog(const __half a) {
    __half val;
    asm("{.reg.b32         f, C;           \n"
        " .reg.b16         r,h;            \n"
        "  mov.b16         h,%1;           \n"
        "  cvt.f32.f16     f,h;            \n"
        "  lg2.approx.f32      f,f;        \n"
        "  mov.b32         C, 0x3f317218;  \n"
        "  mul.f32         f,f,C;          \n"
        "  cvt.rn.f16.f32      r,f;        \n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X160D"";\n" "  mov.b16 ulp,""0x9C00"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X3BFE"";\n" "  mov.b16 ulp,""0x8010"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X3C0B"";\n" "  mov.b16 ulp,""0x8080"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0X6051"";\n" "  mov.b16 ulp,""0x1C00"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b16         %0,r;           \n"
        "}": "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2log(const __half2 a) {
    __half2 val;
    asm("{.reg.b16         hl, hu;             \n"
        " .reg.b32         r, fl, fu, C, h;    \n"
        "  mov.b32         {hl, hu}, %1;       \n"
        "  mov.b32         h, %1;              \n"
        "  cvt.f32.f16     fl, hl;             \n"
        "  cvt.f32.f16     fu, hu;             \n"
        "  lg2.approx.f32      fl, fl;         \n"
        "  lg2.approx.f32      fu, fu;         \n"
        "  mov.b32         C, 0x3f317218;      \n"
        "  mul.f32         fl,fl,C;            \n"
        "  mul.f32         fu,fu,C;            \n"
        "  cvt.rn.f16.f32      hl, fl;         \n"
        "  cvt.rn.f16.f32      hu, fu;         \n"
        "  mov.b32         r, {hl, hu};        \n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X160D160D"";\n" "  mov.b32 ulp,""0x9C009C00"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X3BFE3BFE"";\n" "  mov.b32 ulp,""0x80108010"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X3C0B3C0B"";\n" "  mov.b32 ulp,""0x80808080"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0X60516051"";\n" "  mov.b32 ulp,""0x1C001C00"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b32         %0, r;              \n"
        "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half hlog10(const __half a) {
    __half val;
    asm("{.reg.b16         h, r;           \n"
        " .reg.b32         f, C;           \n"
        "  mov.b16         h, %1;          \n"
        "  cvt.f32.f16     f, h;           \n"
        "  lg2.approx.f32      f, f;       \n"
        "  mov.b32         C, 0x3E9A209B;  \n"
        "  mul.f32         f,f,C;          \n"
        "  cvt.rn.f16.f32      r, f;       \n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x338F"";\n" "  mov.b16 ulp,""0x1000"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x33F8"";\n" "  mov.b16 ulp,""0x9000"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x57E1"";\n" "  mov.b16 ulp,""0x9800"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b16 spc, ulp, p;\n" "  mov.b16 spc,""0x719D"";\n" "  mov.b16 ulp,""0x9C00"";\n" "  set.eq.f16.f16 p,""h"", spc;\n" "  fma.rn.f16 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b16         %0, r;          \n"
        "}":"=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    return val;
}
static __attribute__((device)) __inline__ __half2 h2log10(const __half2 a) {
    __half2 val;
    asm("{.reg.b16         hl, hu;             \n"
        " .reg.b32         r, fl, fu, C, h;    \n"
        "  mov.b32         {hl, hu}, %1;       \n"
        "  mov.b32         h, %1;              \n"
        "  cvt.f32.f16     fl, hl;             \n"
        "  cvt.f32.f16     fu, hu;             \n"
        "  lg2.approx.f32      fl, fl;         \n"
        "  lg2.approx.f32      fu, fu;         \n"
        "  mov.b32         C, 0x3E9A209B;      \n"
        "  mul.f32         fl,fl,C;            \n"
        "  mul.f32         fu,fu,C;            \n"
        "  cvt.rn.f16.f32      hl, fl;         \n"
        "  cvt.rn.f16.f32      hu, fu;         \n"
        "  mov.b32         r, {hl, hu};        \n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x338F338F"";\n" "  mov.b32 ulp,""0x10001000"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x33F833F8"";\n" "  mov.b32 ulp,""0x90009000"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x57E157E1"";\n" "  mov.b32 ulp,""0x98009800"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "{.reg.b32 spc, ulp, p;\n" "  mov.b32 spc,""0x719D719D"";\n" "  mov.b32 ulp,""0x9C009C00"";\n" "  set.eq.f16x2.f16x2 p,""h"", spc;\n" "  fma.rn.f16x2 ""r"",p,ulp,""r"";\n}\n"
        "  mov.b32         %0, r;              \n"
        "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return val;
}


static __attribute__((device)) __inline__ __half2 h2rcp(const __half2 a) {
    do { __half2 val; asm("{.reg.b16         hl, hu;         \n" " .reg.b32         fl, fu;         \n" "  mov.b32         {hl, hu}, %1;   \n" "  cvt.f32.f16     fl, hl;         \n" "  cvt.f32.f16     fu, hu;         \n" "  ""rcp"".approx.f32   fl, fl;     \n" "  ""rcp"".approx.f32   fu, fu;     \n" "  cvt.rn.f16.f32      hl, fl;     \n" "  cvt.rn.f16.f32      hu, fu;     \n" "  mov.b32         %0, {hl, hu};   \n" "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a))))); return val;} while(0);;
}
static __attribute__((device)) __inline__ __half hrcp(const __half a) {
    do { __half val; asm("{.reg.b32         f;        \n" " .reg.b16         r;        \n" "  mov.b16         r,%1;     \n" "  cvt.f32.f16     f,r;      \n" "  ""rcp"".approx.f32   f,f;  \n" "  cvt.rn.f16.f32      r,f;  \n" "  mov.b16         %0,r;     \n" "}": "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a))))); return val;} while(0);;
}
static __attribute__((device)) __inline__ __half2 h2rsqrt(const __half2 a) {
    do { __half2 val; asm("{.reg.b16         hl, hu;         \n" " .reg.b32         fl, fu;         \n" "  mov.b32         {hl, hu}, %1;   \n" "  cvt.f32.f16     fl, hl;         \n" "  cvt.f32.f16     fu, hu;         \n" "  ""rsqrt"".approx.f32   fl, fl;     \n" "  ""rsqrt"".approx.f32   fu, fu;     \n" "  cvt.rn.f16.f32      hl, fl;     \n" "  cvt.rn.f16.f32      hu, fu;     \n" "  mov.b32         %0, {hl, hu};   \n" "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a))))); return val;} while(0);;
}
static __attribute__((device)) __inline__ __half hrsqrt(const __half a) {
    do { __half val; asm("{.reg.b32         f;        \n" " .reg.b16         r;        \n" "  mov.b16         r,%1;     \n" "  cvt.f32.f16     f,r;      \n" "  ""rsqrt"".approx.f32   f,f;  \n" "  cvt.rn.f16.f32      r,f;  \n" "  mov.b16         %0,r;     \n" "}": "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a))))); return val;} while(0);;
}
static __attribute__((device)) __inline__ __half2 h2sqrt(const __half2 a) {
    do { __half2 val; asm("{.reg.b16         hl, hu;         \n" " .reg.b32         fl, fu;         \n" "  mov.b32         {hl, hu}, %1;   \n" "  cvt.f32.f16     fl, hl;         \n" "  cvt.f32.f16     fu, hu;         \n" "  ""sqrt"".approx.f32   fl, fl;     \n" "  ""sqrt"".approx.f32   fu, fu;     \n" "  cvt.rn.f16.f32      hl, fl;     \n" "  cvt.rn.f16.f32      hu, fu;     \n" "  mov.b32         %0, {hl, hu};   \n" "}":"=r"(*(reinterpret_cast<unsigned int *>(&(val)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a))))); return val;} while(0);;
}
static __attribute__((device)) __inline__ __half hsqrt(const __half a) {
    do { __half val; asm("{.reg.b32         f;        \n" " .reg.b16         r;        \n" "  mov.b16         r,%1;     \n" "  cvt.f32.f16     f,r;      \n" "  ""sqrt"".approx.f32   f,f;  \n" "  cvt.rn.f16.f32      r,f;  \n" "  mov.b16         %0,r;     \n" "}": "=h"(*(reinterpret_cast<unsigned short *>(&(val)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a))))); return val;} while(0);;
}


static __attribute__((device)) __inline__ __half2 __hisnan2(const __half2 a)
{
    __half2 r;
    asm("{set.nan.f16x2.f16x2 %0,%1,%2;\n}"
        :"=r"(*(reinterpret_cast<unsigned int *>(&(r)))) : "r"(*(reinterpret_cast<const unsigned int *>(&(a)))), "r"(*(reinterpret_cast<const unsigned int *>(&(a)))));
    return r;
}
static __attribute__((device)) __inline__ bool __hisnan(const __half a)
{
    __half r;
    asm("{set.nan.f16.f16 %0,%1,%2;\n}"
        :"=h"(*(reinterpret_cast<unsigned short *>(&(r)))) : "h"(*(reinterpret_cast<const unsigned short *>(&(a)))), "h"(*(reinterpret_cast<const unsigned short *>(&(a)))));
    if (*(reinterpret_cast<const unsigned short *>(&(r))) == 0)
        return false;
    else return true;
}
static __attribute__((device)) __inline__ __half2 __hneg2(const __half2 a)
{
    __half2 zero = __float2half2_rn(0.0);
    return __hsub2(zero, a);
}
static __attribute__((device)) __inline__ __half __hneg(const __half a)
{
    __half zero;
    zero = __float2half(0.0);
    return __hsub(zero, a);
}
# 1793 "/usr/local/cuda/include/cuda_fp16.hpp"
typedef __half half;
typedef __half2 half2;
# 1968 "/usr/local/cuda/include/cuda_fp16.h" 2
# 76 "/usr/local/cuda/include/cublas_api.h" 2





extern "C" {



typedef enum{
    CUBLAS_STATUS_SUCCESS =0,
    CUBLAS_STATUS_NOT_INITIALIZED =1,
    CUBLAS_STATUS_ALLOC_FAILED =3,
    CUBLAS_STATUS_INVALID_VALUE =7,
    CUBLAS_STATUS_ARCH_MISMATCH =8,
    CUBLAS_STATUS_MAPPING_ERROR =11,
    CUBLAS_STATUS_EXECUTION_FAILED=13,
    CUBLAS_STATUS_INTERNAL_ERROR =14,
    CUBLAS_STATUS_NOT_SUPPORTED =15,
    CUBLAS_STATUS_LICENSE_ERROR =16
} cublasStatus_t;


typedef enum {
    CUBLAS_FILL_MODE_LOWER=0,
    CUBLAS_FILL_MODE_UPPER=1
} cublasFillMode_t;

typedef enum {
    CUBLAS_DIAG_NON_UNIT=0,
    CUBLAS_DIAG_UNIT=1
} cublasDiagType_t;

typedef enum {
    CUBLAS_SIDE_LEFT =0,
    CUBLAS_SIDE_RIGHT=1
} cublasSideMode_t;


typedef enum {
    CUBLAS_OP_N=0,
    CUBLAS_OP_T=1,
    CUBLAS_OP_C=2
} cublasOperation_t;


typedef enum {
    CUBLAS_POINTER_MODE_HOST = 0,
    CUBLAS_POINTER_MODE_DEVICE = 1
} cublasPointerMode_t;

typedef enum {
    CUBLAS_ATOMICS_NOT_ALLOWED = 0,
    CUBLAS_ATOMICS_ALLOWED = 1
} cublasAtomicsMode_t;


typedef enum {
    CUBLAS_GEMM_DFALT = -1,
    CUBLAS_GEMM_DEFAULT = -1,
    CUBLAS_GEMM_ALGO0 = 0,
    CUBLAS_GEMM_ALGO1 = 1,
    CUBLAS_GEMM_ALGO2 = 2,
    CUBLAS_GEMM_ALGO3 = 3,
    CUBLAS_GEMM_ALGO4 = 4,
    CUBLAS_GEMM_ALGO5 = 5,
    CUBLAS_GEMM_ALGO6 = 6,
    CUBLAS_GEMM_ALGO7 = 7,
    CUBLAS_GEMM_ALGO8 = 8,
    CUBLAS_GEMM_ALGO9 = 9,
    CUBLAS_GEMM_ALGO10 = 10,
    CUBLAS_GEMM_ALGO11 = 11,
    CUBLAS_GEMM_ALGO12 = 12,
    CUBLAS_GEMM_ALGO13 = 13,
    CUBLAS_GEMM_ALGO14 = 14,
    CUBLAS_GEMM_ALGO15 = 15,
    CUBLAS_GEMM_ALGO16 = 16,
    CUBLAS_GEMM_ALGO17 = 17,
    CUBLAS_GEMM_DEFAULT_TENSOR_OP = 99,
    CUBLAS_GEMM_DFALT_TENSOR_OP = 99,
    CUBLAS_GEMM_ALGO0_TENSOR_OP = 100,
    CUBLAS_GEMM_ALGO1_TENSOR_OP = 101,
    CUBLAS_GEMM_ALGO2_TENSOR_OP = 102,
    CUBLAS_GEMM_ALGO3_TENSOR_OP = 103,
    CUBLAS_GEMM_ALGO4_TENSOR_OP = 104
} cublasGemmAlgo_t;


typedef enum {
    CUBLAS_DEFAULT_MATH = 0,
    CUBLAS_TENSOR_OP_MATH = 1
} cublasMath_t;


typedef cudaDataType cublasDataType_t;


struct cublasContext;
typedef struct cublasContext *cublasHandle_t;

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCreate_v2 (cublasHandle_t *handle);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDestroy_v2 (cublasHandle_t handle);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGetVersion_v2(cublasHandle_t handle, int *version);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGetProperty(libraryPropertyType type, int *value);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSetStream_v2 (cublasHandle_t handle, cudaStream_t streamId);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGetStream_v2 (cublasHandle_t handle, cudaStream_t *streamId);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGetPointerMode_v2 (cublasHandle_t handle, cublasPointerMode_t *mode);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSetPointerMode_v2 (cublasHandle_t handle, cublasPointerMode_t mode);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGetAtomicsMode(cublasHandle_t handle, cublasAtomicsMode_t *mode);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSetAtomicsMode(cublasHandle_t handle, cublasAtomicsMode_t mode);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGetMathMode(cublasHandle_t handle, cublasMath_t *mode);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSetMathMode(cublasHandle_t handle, cublasMath_t mode);
# 217 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasSetVector (int n, int elemSize, const void *x,
                                             int incx, void *devicePtr, int incy);
# 243 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasGetVector (int n, int elemSize, const void *x,
                                             int incx, void *y, int incy);
# 267 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasSetMatrix (int rows, int cols, int elemSize,
                                             const void *A, int lda, void *B,
                                             int ldb);
# 291 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasGetMatrix (int rows, int cols, int elemSize,
                                             const void *A, int lda, void *B,
                                             int ldb);
# 311 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasSetVectorAsync (int n, int elemSize,
                                                  const void *hostPtr, int incx,
                                                  void *devicePtr, int incy,
                                                  cudaStream_t stream);
# 331 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasGetVectorAsync (int n, int elemSize,
                                                  const void *devicePtr, int incx,
                                                  void *hostPtr, int incy,
                                                  cudaStream_t stream);
# 353 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasSetMatrixAsync (int rows, int cols, int elemSize,
                                                  const void *A, int lda, void *B,
                                                  int ldb, cudaStream_t stream);
# 373 "/usr/local/cuda/include/cublas_api.h"
cublasStatus_t cublasGetMatrixAsync (int rows, int cols, int elemSize,
                                                  const void *A, int lda, void *B,
                                                  int ldb, cudaStream_t stream);


__attribute__((host)) __attribute__((device)) void cublasXerbla (const char *srName, int info);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasNrm2Ex(cublasHandle_t handle,
                                                     int n,
                                                     const void *x,
                                                     cudaDataType xType,
                                                     int incx,
                                                     void *result,
                                                     cudaDataType resultType,
                                                     cudaDataType executionType);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSnrm2_v2(cublasHandle_t handle,
                                                     int n,
                                                     const float *x,
                                                     int incx,
                                                     float *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDnrm2_v2(cublasHandle_t handle,
                                                     int n,
                                                     const double *x,
                                                     int incx,
                                                     double *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasScnrm2_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      float *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDznrm2_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      double *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDotEx (cublasHandle_t handle,
                                                     int n,
                                                     const void *x,
                                                     cudaDataType xType,
                                                     int incx,
                                                     const void *y,
                                                     cudaDataType yType,
                                                     int incy,
                                                     void *result,
                                                     cudaDataType resultType,
                                                     cudaDataType executionType);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDotcEx (cublasHandle_t handle,
                                                     int n,
                                                     const void *x,
                                                     cudaDataType xType,
                                                     int incx,
                                                     const void *y,
                                                     cudaDataType yType,
                                                     int incy,
                                                     void *result,
                                                     cudaDataType resultType,
                                                     cudaDataType executionType);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSdot_v2 (cublasHandle_t handle,
                                                     int n,
                                                     const float *x,
                                                     int incx,
                                                     const float *y,
                                                     int incy,
                                                     float *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDdot_v2 (cublasHandle_t handle,
                                                     int n,
                                                     const double *x,
                                                     int incx,
                                                     const double *y,
                                                     int incy,
                                                     double *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCdotu_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCdotc_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZdotu_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZdotc_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasScalEx(cublasHandle_t handle,
                                                     int n,
                                                     const void *alpha,
                                                     cudaDataType alphaType,
                                                     void *x,
                                                     cudaDataType xType,
                                                     int incx,
                                                     cudaDataType executionType);
__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSscal_v2(cublasHandle_t handle,
                                                     int n,
                                                     const float *alpha,
                                                     float *x,
                                                     int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDscal_v2(cublasHandle_t handle,
                                                     int n,
                                                     const double *alpha,
                                                     double *x,
                                                     int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCscal_v2(cublasHandle_t handle,
                                                     int n,
                                                     const cuComplex *alpha,
                                                     cuComplex *x,
                                                     int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsscal_v2(cublasHandle_t handle,
                                                      int n,
                                                      const float *alpha,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZscal_v2(cublasHandle_t handle,
                                                     int n,
                                                     const cuDoubleComplex *alpha,
                                                     cuDoubleComplex *x,
                                                     int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZdscal_v2(cublasHandle_t handle,
                                                      int n,
                                                      const double *alpha,
                                                      cuDoubleComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasAxpyEx (cublasHandle_t handle,
                                                      int n,
                                                      const void *alpha,
                                                      cudaDataType alphaType,
                                                      const void *x,
                                                      cudaDataType xType,
                                                      int incx,
                                                      void *y,
                                                      cudaDataType yType,
                                                      int incy,
                                                      cudaDataType executiontype);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSaxpy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const float *alpha,
                                                      const float *x,
                                                      int incx,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDaxpy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const double *alpha,
                                                      const double *x,
                                                      int incx,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCaxpy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *x,
                                                      int incx,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZaxpy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      cuDoubleComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasScopy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const float *x,
                                                      int incx,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDcopy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const double *x,
                                                      int incx,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCcopy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZcopy_v2 (cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      cuDoubleComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSswap_v2 (cublasHandle_t handle,
                                                      int n,
                                                      float *x,
                                                      int incx,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDswap_v2 (cublasHandle_t handle,
                                                      int n,
                                                      double *x,
                                                      int incx,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCswap_v2 (cublasHandle_t handle,
                                                      int n,
                                                      cuComplex *x,
                                                      int incx,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZswap_v2 (cublasHandle_t handle,
                                                      int n,
                                                      cuDoubleComplex *x,
                                                      int incx,
                                                      cuDoubleComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIsamax_v2(cublasHandle_t handle,
                                                      int n,
                                                      const float *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIdamax_v2(cublasHandle_t handle,
                                                      int n,
                                                      const double *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIcamax_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIzamax_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIsamin_v2(cublasHandle_t handle,
                                                      int n,
                                                      const float *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIdamin_v2(cublasHandle_t handle,
                                                      int n,
                                                      const double *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIcamin_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasIzamin_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      int *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSasum_v2(cublasHandle_t handle,
                                                     int n,
                                                     const float *x,
                                                     int incx,
                                                     float *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDasum_v2(cublasHandle_t handle,
                                                     int n,
                                                     const double *x,
                                                     int incx,
                                                     double *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasScasum_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuComplex *x,
                                                      int incx,
                                                      float *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDzasum_v2(cublasHandle_t handle,
                                                      int n,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      double *result);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSrot_v2 (cublasHandle_t handle,
                                                     int n,
                                                     float *x,
                                                     int incx,
                                                     float *y,
                                                     int incy,
                                                     const float *c,
                                                     const float *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDrot_v2 (cublasHandle_t handle,
                                                     int n,
                                                     double *x,
                                                     int incx,
                                                     double *y,
                                                     int incy,
                                                     const double *c,
                                                     const double *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCrot_v2 (cublasHandle_t handle,
                                                     int n,
                                                     cuComplex *x,
                                                     int incx,
                                                     cuComplex *y,
                                                     int incy,
                                                     const float *c,
                                                     const cuComplex *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsrot_v2(cublasHandle_t handle,
                                                     int n,
                                                     cuComplex *x,
                                                     int incx,
                                                     cuComplex *y,
                                                     int incy,
                                                     const float *c,
                                                     const float *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZrot_v2 (cublasHandle_t handle,
                                                     int n,
                                                     cuDoubleComplex *x,
                                                     int incx,
                                                     cuDoubleComplex *y,
                                                     int incy,
                                                     const double *c,
                                                     const cuDoubleComplex *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZdrot_v2(cublasHandle_t handle,
                                                     int n,
                                                     cuDoubleComplex *x,
                                                     int incx,
                                                     cuDoubleComplex *y,
                                                     int incy,
                                                     const double *c,
                                                     const double *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSrotg_v2(cublasHandle_t handle,
                                                     float *a,
                                                     float *b,
                                                     float *c,
                                                     float *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDrotg_v2(cublasHandle_t handle,
                                                     double *a,
                                                     double *b,
                                                     double *c,
                                                     double *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCrotg_v2(cublasHandle_t handle,
                                                     cuComplex *a,
                                                     cuComplex *b,
                                                     float *c,
                                                     cuComplex *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZrotg_v2(cublasHandle_t handle,
                                                     cuDoubleComplex *a,
                                                     cuDoubleComplex *b,
                                                     double *c,
                                                     cuDoubleComplex *s);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSrotm_v2(cublasHandle_t handle,
                                                     int n,
                                                     float *x,
                                                     int incx,
                                                     float *y,
                                                     int incy,
                                                     const float* param);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDrotm_v2(cublasHandle_t handle,
                                                     int n,
                                                     double *x,
                                                     int incx,
                                                     double *y,
                                                     int incy,
                                                     const double* param);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSrotmg_v2(cublasHandle_t handle,
                                                      float *d1,
                                                      float *d2,
                                                      float *x1,
                                                      const float *y1,
                                                      float *param);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDrotmg_v2(cublasHandle_t handle,
                                                      double *d1,
                                                      double *d2,
                                                      double *x1,
                                                      const double *y1,
                                                      double *param);




__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgemv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *x,
                                                      int incx,
                                                      const float *beta,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgemv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *x,
                                                      int incx,
                                                      const double *beta,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *beta,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgemv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgbmv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      int kl,
                                                      int ku,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *x,
                                                      int incx,
                                                      const float *beta,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgbmv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      int kl,
                                                      int ku,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *x,
                                                      int incx,
                                                      const double *beta,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgbmv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      int kl,
                                                      int ku,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *beta,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgbmv_v2 (cublasHandle_t handle,
                                                      cublasOperation_t trans,
                                                      int m,
                                                      int n,
                                                      int kl,
                                                      int ku,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *y,
                                                      int incy);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStrmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const float *A,
                                                      int lda,
                                                      float *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtrmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const double *A,
                                                      int lda,
                                                      double *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtrmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuComplex *A,
                                                      int lda,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtrmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      cuDoubleComplex *x,
                                                      int incx);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const float *A,
                                                      int lda,
                                                      float *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const double *A,
                                                      int lda,
                                                      double *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const cuComplex *A,
                                                      int lda,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      cuDoubleComplex *x,
                                                      int incx);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStpmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const float *AP,
                                                      float *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtpmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const double *AP,
                                                      double *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtpmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuComplex *AP,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtpmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuDoubleComplex *AP,
                                                      cuDoubleComplex *x,
                                                      int incx);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStrsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const float *A,
                                                      int lda,
                                                      float *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtrsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const double *A,
                                                      int lda,
                                                      double *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtrsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuComplex *A,
                                                      int lda,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtrsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      cuDoubleComplex *x,
                                                      int incx);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStpsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const float *AP,
                                                      float *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtpsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const double *AP,
                                                      double *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtpsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuComplex *AP,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtpsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      const cuDoubleComplex *AP,
                                                      cuDoubleComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStbsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const float *A,
                                                      int lda,
                                                      float *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtbsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const double *A,
                                                      int lda,
                                                      double *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtbsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const cuComplex *A,
                                                      int lda,
                                                      cuComplex *x,
                                                      int incx);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtbsv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int n,
                                                      int k,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      cuDoubleComplex *x,
                                                      int incx);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsymv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *x,
                                                      int incx,
                                                      const float *beta,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsymv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *x,
                                                      int incx,
                                                      const double *beta,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsymv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *beta,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsymv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasChemv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *beta,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZhemv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *y,
                                                      int incy);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      int k,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *x,
                                                      int incx,
                                                      const float *beta,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      int k,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *x,
                                                      int incx,
                                                      const double *beta,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasChbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      int k,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *beta,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZhbmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      int k,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *y,
                                                      int incy);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSspmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const float *alpha,
                                                      const float *AP,
                                                      const float *x,
                                                      int incx,
                                                      const float *beta,
                                                      float *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDspmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const double *alpha,
                                                      const double *AP,
                                                      const double *x,
                                                      int incx,
                                                      const double *beta,
                                                      double *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasChpmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *AP,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *beta,
                                                      cuComplex *y,
                                                      int incy);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZhpmv_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *AP,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *y,
                                                      int incy);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSger_v2 (cublasHandle_t handle,
                                                     int m,
                                                     int n,
                                                     const float *alpha,
                                                     const float *x,
                                                     int incx,
                                                     const float *y,
                                                     int incy,
                                                     float *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDger_v2 (cublasHandle_t handle,
                                                     int m,
                                                     int n,
                                                     const double *alpha,
                                                     const double *x,
                                                     int incx,
                                                     const double *y,
                                                     int incy,
                                                     double *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgeru_v2 (cublasHandle_t handle,
                                                      int m,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgerc_v2 (cublasHandle_t handle,
                                                      int m,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgeru_v2 (cublasHandle_t handle,
                                                      int m,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgerc_v2 (cublasHandle_t handle,
                                                      int m,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *A,
                                                      int lda);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsyr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const float *alpha,
                                                     const float *x,
                                                     int incx,
                                                     float *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsyr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const double *alpha,
                                                     const double *x,
                                                     int incx,
                                                     double *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const cuComplex *alpha,
                                                     const cuComplex *x,
                                                     int incx,
                                                     cuComplex *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsyr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const cuDoubleComplex *alpha,
                                                     const cuDoubleComplex *x,
                                                     int incx,
                                                     cuDoubleComplex *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCher_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const float *alpha,
                                                     const cuComplex *x,
                                                     int incx,
                                                     cuComplex *A,
                                                     int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZher_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const double *alpha,
                                                     const cuDoubleComplex *x,
                                                     int incx,
                                                     cuDoubleComplex *A,
                                                     int lda);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSspr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const float *alpha,
                                                     const float *x,
                                                     int incx,
                                                     float *AP);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDspr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const double *alpha,
                                                     const double *x,
                                                     int incx,
                                                     double *AP);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasChpr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const float *alpha,
                                                     const cuComplex *x,
                                                     int incx,
                                                     cuComplex *AP);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZhpr_v2 (cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const double *alpha,
                                                     const cuDoubleComplex *x,
                                                     int incx,
                                                     cuDoubleComplex *AP);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsyr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const float *alpha,
                                                      const float *x,
                                                      int incx,
                                                      const float *y,
                                                      int incy,
                                                      float *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsyr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const double *alpha,
                                                      const double *x,
                                                      int incx,
                                                      const double *y,
                                                      int incy,
                                                      double *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo, int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsyr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *A,
                                                      int lda);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCher2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo, int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *A,
                                                      int lda);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZher2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *A,
                                                      int lda);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSspr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const float *alpha,
                                                      const float *x,
                                                      int incx,
                                                      const float *y,
                                                      int incy,
                                                      float *AP);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDspr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const double *alpha,
                                                      const double *x,
                                                      int incx,
                                                      const double *y,
                                                      int incy,
                                                      double *AP);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasChpr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *x,
                                                      int incx,
                                                      const cuComplex *y,
                                                      int incy,
                                                      cuComplex *AP);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZhpr2_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *x,
                                                      int incx,
                                                      const cuDoubleComplex *y,
                                                      int incy,
                                                      cuDoubleComplex *AP);




__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgemm_v2 (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *B,
                                                      int ldb,
                                                      const float *beta,
                                                      float *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgemm_v2 (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *B,
                                                      int ldb,
                                                      const double *beta,
                                                      double *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemm_v2 (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *B,
                                                      int ldb,
                                                      const cuComplex *beta,
                                                      cuComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemm3m (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *B,
                                                      int ldb,
                                                      const cuComplex *beta,
                                                      cuComplex *C,
                                                      int ldc);
 __attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemm3mEx (cublasHandle_t handle,
                                                     cublasOperation_t transa, cublasOperation_t transb,
                                                     int m, int n, int k,
                                                     const cuComplex *alpha,
                                                     const void *A,
                                                     cudaDataType Atype,
                                                     int lda,
                                                     const void *B,
                                                     cudaDataType Btype,
                                                     int ldb,
                                                     const cuComplex *beta,
                                                     void *C,
                                                     cudaDataType Ctype,
                                                     int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgemm_v2 (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *B,
                                                      int ldb,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgemm3m (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *B,
                                                      int ldb,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *C,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasHgemm (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const __half *alpha,
                                                      const __half *A,
                                                      int lda,
                                                      const __half *B,
                                                      int ldb,
                                                      const __half *beta,
                                                      __half *C,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgemmEx (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const float *alpha,
                                                      const void *A,
                                                      cudaDataType Atype,
                                                      int lda,
                                                      const void *B,
                                                      cudaDataType Btype,
                                                      int ldb,
                                                      const float *beta,
                                                      void *C,
                                                      cudaDataType Ctype,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasGemmEx (cublasHandle_t handle,
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb,
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const void *alpha,
                                                      const void *A,
                                                      cudaDataType Atype,
                                                      int lda,
                                                      const void *B,
                                                      cudaDataType Btype,
                                                      int ldb,
                                                      const void *beta,
                                                      void *C,
                                                      cudaDataType Ctype,
                                                      int ldc,
                                                      cudaDataType computeType,
                                                      cublasGemmAlgo_t algo);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemmEx (cublasHandle_t handle,
                                                     cublasOperation_t transa, cublasOperation_t transb,
                                                     int m, int n, int k,
                                                     const cuComplex *alpha,
                                                     const void *A,
                                                     cudaDataType Atype,
                                                     int lda,
                                                     const void *B,
                                                     cudaDataType Btype,
                                                     int ldb,
                                                     const cuComplex *beta,
                                                     void *C,
                                                     cudaDataType Ctype,
                                                     int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasUint8gemmBias (cublasHandle_t handle,
                                                           cublasOperation_t transa, cublasOperation_t transb, cublasOperation_t transc,
                                                           int m, int n, int k,
                                                           const unsigned char *A, int A_bias, int lda,
                                                           const unsigned char *B, int B_bias, int ldb,
                                                                 unsigned char *C, int C_bias, int ldc,
                                                           int C_mult, int C_shift);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsyrk_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *beta,
                                                      float *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsyrk_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *beta,
                                                      double *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyrk_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *beta,
                                                      cuComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsyrk_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyrkEx ( cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const cuComplex *alpha,
                                                      const void *A,
                                                      cudaDataType Atype,
                                                      int lda,
                                                      const cuComplex *beta,
                                                      void *C,
                                                      cudaDataType Ctype,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyrk3mEx(cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const cuComplex *alpha,
                                                      const void *A,
                                                      cudaDataType Atype,
                                                      int lda,
                                                      const cuComplex *beta,
                                                      void *C,
                                                      cudaDataType Ctype,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCherk_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const float *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const float *beta,
                                                      cuComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZherk_v2 (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const double *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const double *beta,
                                                      cuDoubleComplex *C,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCherkEx (cublasHandle_t handle,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      int n,
                                                      int k,
                                                      const float *alpha,
                                                      const void *A,
                                                      cudaDataType Atype,
                                                      int lda,
                                                      const float *beta,
                                                      void *C,
                                                      cudaDataType Ctype,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCherk3mEx (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const float *alpha,
                                                       const void *A, cudaDataType Atype,
                                                       int lda,
                                                       const float *beta,
                                                       void *C,
                                                       cudaDataType Ctype,
                                                       int ldc);




__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsyr2k_v2 (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const float *alpha,
                                                       const float *A,
                                                       int lda,
                                                       const float *B,
                                                       int ldb,
                                                       const float *beta,
                                                       float *C,
                                                       int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsyr2k_v2 (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const double *alpha,
                                                       const double *A,
                                                       int lda,
                                                       const double *B,
                                                       int ldb,
                                                       const double *beta,
                                                       double *C,
                                                       int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyr2k_v2 (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const cuComplex *alpha,
                                                       const cuComplex *A,
                                                       int lda,
                                                       const cuComplex *B,
                                                       int ldb,
                                                       const cuComplex *beta,
                                                       cuComplex *C,
                                                       int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsyr2k_v2 (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const cuDoubleComplex *alpha,
                                                       const cuDoubleComplex *A,
                                                       int lda,
                                                       const cuDoubleComplex *B,
                                                       int ldb,
                                                       const cuDoubleComplex *beta,
                                                       cuDoubleComplex *C,
                                                       int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCher2k_v2 (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const cuComplex *alpha,
                                                       const cuComplex *A,
                                                       int lda,
                                                       const cuComplex *B,
                                                       int ldb,
                                                       const float *beta,
                                                       cuComplex *C,
                                                       int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZher2k_v2 (cublasHandle_t handle,
                                                       cublasFillMode_t uplo,
                                                       cublasOperation_t trans,
                                                       int n,
                                                       int k,
                                                       const cuDoubleComplex *alpha,
                                                       const cuDoubleComplex *A,
                                                       int lda,
                                                       const cuDoubleComplex *B,
                                                       int ldb,
                                                       const double *beta,
                                                       cuDoubleComplex *C,
                                                       int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsyrkx (cublasHandle_t handle,
                                                    cublasFillMode_t uplo,
                                                    cublasOperation_t trans,
                                                    int n,
                                                    int k,
                                                    const float *alpha,
                                                    const float *A,
                                                    int lda,
                                                    const float *B,
                                                    int ldb,
                                                    const float *beta,
                                                    float *C,
                                                    int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsyrkx (cublasHandle_t handle,
                                                    cublasFillMode_t uplo,
                                                    cublasOperation_t trans,
                                                    int n,
                                                    int k,
                                                    const double *alpha,
                                                    const double *A,
                                                    int lda,
                                                    const double *B,
                                                    int ldb,
                                                    const double *beta,
                                                    double *C,
                                                    int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsyrkx (cublasHandle_t handle,
                                                    cublasFillMode_t uplo,
                                                    cublasOperation_t trans,
                                                    int n,
                                                    int k,
                                                    const cuComplex *alpha,
                                                    const cuComplex *A,
                                                    int lda,
                                                    const cuComplex *B,
                                                    int ldb,
                                                    const cuComplex *beta,
                                                    cuComplex *C,
                                                    int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsyrkx (cublasHandle_t handle,
                                                    cublasFillMode_t uplo,
                                                    cublasOperation_t trans,
                                                    int n,
                                                    int k,
                                                    const cuDoubleComplex *alpha,
                                                    const cuDoubleComplex *A,
                                                    int lda,
                                                    const cuDoubleComplex *B,
                                                    int ldb,
                                                    const cuDoubleComplex *beta,
                                                    cuDoubleComplex *C,
                                                    int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCherkx (cublasHandle_t handle,
                                                    cublasFillMode_t uplo,
                                                    cublasOperation_t trans,
                                                    int n,
                                                    int k,
                                                    const cuComplex *alpha,
                                                    const cuComplex *A,
                                                    int lda,
                                                    const cuComplex *B,
                                                    int ldb,
                                                    const float *beta,
                                                    cuComplex *C,
                                                    int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZherkx (cublasHandle_t handle,
                                                    cublasFillMode_t uplo,
                                                    cublasOperation_t trans,
                                                    int n,
                                                    int k,
                                                    const cuDoubleComplex *alpha,
                                                    const cuDoubleComplex *A,
                                                    int lda,
                                                    const cuDoubleComplex *B,
                                                    int ldb,
                                                    const double *beta,
                                                    cuDoubleComplex *C,
                                                    int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSsymm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      int m,
                                                      int n,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *B,
                                                      int ldb,
                                                      const float *beta,
                                                      float *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDsymm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      int m,
                                                      int n,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *B,
                                                      int ldb,
                                                      const double *beta,
                                                      double *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCsymm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      int m,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *B,
                                                      int ldb,
                                                      const cuComplex *beta,
                                                      cuComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZsymm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      int m,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *B,
                                                      int ldb,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *C,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasChemm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      int m,
                                                      int n,
                                                      const cuComplex *alpha,
                                                      const cuComplex *A,
                                                      int lda,
                                                      const cuComplex *B,
                                                      int ldb,
                                                      const cuComplex *beta,
                                                      cuComplex *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZhemm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      int m,
                                                      int n,
                                                      const cuDoubleComplex *alpha,
                                                      const cuDoubleComplex *A,
                                                      int lda,
                                                      const cuDoubleComplex *B,
                                                      int ldb,
                                                      const cuDoubleComplex *beta,
                                                      cuDoubleComplex *C,
                                                      int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStrsm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int m,
                                                      int n,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      float *B,
                                                      int ldb);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtrsm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int m,
                                                      int n,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      double *B,
                                                      int ldb);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtrsm_v2(cublasHandle_t handle,
                                                     cublasSideMode_t side,
                                                     cublasFillMode_t uplo,
                                                     cublasOperation_t trans,
                                                     cublasDiagType_t diag,
                                                     int m,
                                                     int n,
                                                     const cuComplex *alpha,
                                                     const cuComplex *A,
                                                     int lda,
                                                     cuComplex *B,
                                                     int ldb);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtrsm_v2(cublasHandle_t handle,
                                                     cublasSideMode_t side,
                                                     cublasFillMode_t uplo,
                                                     cublasOperation_t trans,
                                                     cublasDiagType_t diag,
                                                     int m,
                                                     int n,
                                                     const cuDoubleComplex *alpha,
                                                     const cuDoubleComplex *A,
                                                     int lda,
                                                     cuDoubleComplex *B,
                                                     int ldb);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStrmm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int m,
                                                      int n,
                                                      const float *alpha,
                                                      const float *A,
                                                      int lda,
                                                      const float *B,
                                                      int ldb,
                                                      float *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtrmm_v2 (cublasHandle_t handle,
                                                      cublasSideMode_t side,
                                                      cublasFillMode_t uplo,
                                                      cublasOperation_t trans,
                                                      cublasDiagType_t diag,
                                                      int m,
                                                      int n,
                                                      const double *alpha,
                                                      const double *A,
                                                      int lda,
                                                      const double *B,
                                                      int ldb,
                                                      double *C,
                                                      int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtrmm_v2(cublasHandle_t handle,
                                                     cublasSideMode_t side,
                                                     cublasFillMode_t uplo,
                                                     cublasOperation_t trans,
                                                     cublasDiagType_t diag,
                                                     int m,
                                                     int n,
                                                     const cuComplex *alpha,
                                                     const cuComplex *A,
                                                     int lda,
                                                     const cuComplex *B,
                                                     int ldb,
                                                     cuComplex *C,
                                                     int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtrmm_v2(cublasHandle_t handle, cublasSideMode_t side,
                                                     cublasFillMode_t uplo,
                                                     cublasOperation_t trans,
                                                     cublasDiagType_t diag,
                                                     int m,
                                                     int n,
                                                     const cuDoubleComplex *alpha,
                                                     const cuDoubleComplex *A,
                                                     int lda,
                                                     const cuDoubleComplex *B,
                                                     int ldb,
                                                     cuDoubleComplex *C,
                                                     int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasHgemmBatched (cublasHandle_t handle,
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb,
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const __half *alpha,
                                                          const __half *Aarray[],
                                                          int lda,
                                                          const __half *Barray[],
                                                          int ldb,
                                                          const __half *beta,
                                                          __half *Carray[],
                                                          int ldc,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgemmBatched (cublasHandle_t handle,
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb,
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const float *alpha,
                                                          const float *Aarray[],
                                                          int lda,
                                                          const float *Barray[],
                                                          int ldb,
                                                          const float *beta,
                                                          float *Carray[],
                                                          int ldc,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgemmBatched (cublasHandle_t handle,
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb,
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const double *alpha,
                                                          const double *Aarray[],
                                                          int lda,
                                                          const double *Barray[],
                                                          int ldb,
                                                          const double *beta,
                                                          double *Carray[],
                                                          int ldc,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemmBatched (cublasHandle_t handle,
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb,
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const cuComplex *alpha,
                                                          const cuComplex *Aarray[],
                                                          int lda,
                                                          const cuComplex *Barray[],
                                                          int ldb,
                                                          const cuComplex *beta,
                                                          cuComplex *Carray[],
                                                          int ldc,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemm3mBatched (cublasHandle_t handle,
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb,
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const cuComplex *alpha,
                                                          const cuComplex *Aarray[],
                                                          int lda,
                                                          const cuComplex *Barray[],
                                                          int ldb,
                                                          const cuComplex *beta,
                                                          cuComplex *Carray[],
                                                          int ldc,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgemmBatched (cublasHandle_t handle,
                                                          cublasOperation_t transa,
                                                          cublasOperation_t transb,
                                                          int m,
                                                          int n,
                                                          int k,
                                                          const cuDoubleComplex *alpha,
                                                          const cuDoubleComplex *Aarray[],
                                                          int lda,
                                                          const cuDoubleComplex *Barray[],
                                                          int ldb,
                                                          const cuDoubleComplex *beta,
                                                          cuDoubleComplex *Carray[],
                                                          int ldc,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgemmStridedBatched (cublasHandle_t handle,
                                                                 cublasOperation_t transa,
                                                                 cublasOperation_t transb,
                                                                 int m,
                                                                 int n,
                                                                 int k,
                                                                 const float *alpha,
                                                                 const float *A,
                                                                 int lda,
                                                                 long long int strideA,
                                                                 const float *B,
                                                                 int ldb,
                                                                 long long int strideB,
                                                                 const float *beta,
                                                                 float *C,
                                                                 int ldc,
                                                                 long long int strideC,
                                                                 int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgemmStridedBatched (cublasHandle_t handle,
                                                                 cublasOperation_t transa,
                                                                 cublasOperation_t transb,
                                                                 int m,
                                                                 int n,
                                                                 int k,
                                                                 const double *alpha,
                                                                 const double *A,
                                                                 int lda,
                                                                 long long int strideA,
                                                                 const double *B,
                                                                 int ldb,
                                                                 long long int strideB,
                                                                 const double *beta,
                                                                 double *C,
                                                                 int ldc,
                                                                 long long int strideC,
                                                                 int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemmStridedBatched (cublasHandle_t handle,
                                                                 cublasOperation_t transa,
                                                                 cublasOperation_t transb,
                                                                 int m,
                                                                 int n,
                                                                 int k,
                                                                 const cuComplex *alpha,
                                                                 const cuComplex *A,
                                                                 int lda,
                                                                 long long int strideA,
                                                                 const cuComplex *B,
                                                                 int ldb,
                                                                 long long int strideB,
                                                                 const cuComplex *beta,
                                                                 cuComplex *C,
                                                                 int ldc,
                                                                 long long int strideC,
                                                                 int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgemm3mStridedBatched (cublasHandle_t handle,
                                                                 cublasOperation_t transa,
                                                                 cublasOperation_t transb,
                                                                 int m,
                                                                 int n,
                                                                 int k,
                                                                 const cuComplex *alpha,
                                                                 const cuComplex *A,
                                                                 int lda,
                                                                 long long int strideA,
                                                                 const cuComplex *B,
                                                                 int ldb,
                                                                 long long int strideB,
                                                                 const cuComplex *beta,
                                                                 cuComplex *C,
                                                                 int ldc,
                                                                 long long int strideC,
                                                                 int batchCount);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgemmStridedBatched (cublasHandle_t handle,
                                                                 cublasOperation_t transa,
                                                                 cublasOperation_t transb,
                                                                 int m,
                                                                 int n,
                                                                 int k,
                                                                 const cuDoubleComplex *alpha,
                                                                 const cuDoubleComplex *A,
                                                                 int lda,
                                                                 long long int strideA,
                                                                 const cuDoubleComplex *B,
                                                                 int ldb,
                                                                 long long int strideB,
                                                                 const cuDoubleComplex *beta,
                                                                 cuDoubleComplex *C,
                                                                 int ldc,
                                                                 long long int strideC,
                                                                 int batchCount);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasHgemmStridedBatched (cublasHandle_t handle,
                                                                 cublasOperation_t transa,
                                                                 cublasOperation_t transb,
                                                                 int m,
                                                                 int n,
                                                                 int k,
                                                                 const __half *alpha,
                                                                 const __half *A,
                                                                 int lda,
                                                                 long long int strideA,
                                                                 const __half *B,
                                                                 int ldb,
                                                                 long long int strideB,
                                                                 const __half *beta,
                                                                 __half *C,
                                                                 int ldc,
                                                                 long long int strideC,
                                                                 int batchCount);



__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgeam(cublasHandle_t handle,
                                                  cublasOperation_t transa,
                                                  cublasOperation_t transb,
                                                  int m,
                                                  int n,
                                                  const float *alpha,
                                                  const float *A,
                                                  int lda,
                                                  const float *beta ,
                                                  const float *B,
                                                  int ldb,
                                                  float *C,
                                                  int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgeam(cublasHandle_t handle,
                                                  cublasOperation_t transa,
                                                  cublasOperation_t transb,
                                                  int m,
                                                  int n,
                                                  const double *alpha,
                                                  const double *A,
                                                  int lda,
                                                  const double *beta,
                                                  const double *B,
                                                  int ldb,
                                                  double *C,
                                                  int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgeam(cublasHandle_t handle,
                                                  cublasOperation_t transa,
                                                  cublasOperation_t transb,
                                                  int m,
                                                  int n,
                                                  const cuComplex *alpha,
                                                  const cuComplex *A,
                                                  int lda,
                                                  const cuComplex *beta,
                                                  const cuComplex *B,
                                                  int ldb,
                                                  cuComplex *C,
                                                  int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgeam(cublasHandle_t handle,
                                                  cublasOperation_t transa,
                                                  cublasOperation_t transb,
                                                  int m,
                                                  int n,
                                                  const cuDoubleComplex *alpha,
                                                  const cuDoubleComplex *A,
                                                  int lda,
                                                  const cuDoubleComplex *beta,
                                                  const cuDoubleComplex *B,
                                                  int ldb,
                                                  cuDoubleComplex *C,
                                                  int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgetrfBatched(cublasHandle_t handle,
                                                  int n,
                                                  float *A[],
                                                  int lda,
                                                  int *P,
                                                  int *info,
                                                  int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgetrfBatched(cublasHandle_t handle,
                                                  int n,
                                                  double *A[],
                                                  int lda,
                                                  int *P,
                                                  int *info,
                                                  int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgetrfBatched(cublasHandle_t handle,
                                                  int n,
                                                  cuComplex *A[],
                                                  int lda,
                                                  int *P,
                                                  int *info,
                                                  int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgetrfBatched(cublasHandle_t handle,
                                                  int n,
                                                  cuDoubleComplex *A[],
                                                  int lda,
                                                  int *P,
                                                  int *info,
                                                  int batchSize);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgetriBatched(cublasHandle_t handle,
                                                  int n,
                                                  const float *A[],
                                                  int lda,
                                                  const int *P,
                                                  float *C[],
                                                  int ldc,
                                                  int *info,
                                                  int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgetriBatched(cublasHandle_t handle,
                                                  int n,
                                                  const double *A[],
                                                  int lda,
                                                  const int *P,
                                                  double *C[],
                                                  int ldc,
                                                  int *info,
                                                  int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgetriBatched(cublasHandle_t handle,
                                                  int n,
                                                  const cuComplex *A[],
                                                  int lda,
                                                  const int *P,
                                                  cuComplex *C[],
                                                  int ldc,
                                                  int *info,
                                                  int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgetriBatched(cublasHandle_t handle,
                                                  int n,
                                                  const cuDoubleComplex *A[],
                                                  int lda,
                                                  const int *P,
                                                  cuDoubleComplex *C[],
                                                  int ldc,
                                                  int *info,
                                                  int batchSize);



__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgetrsBatched( cublasHandle_t handle,
                                                            cublasOperation_t trans,
                                                            int n,
                                                            int nrhs,
                                                            const float *Aarray[],
                                                            int lda,
                                                            const int *devIpiv,
                                                            float *Barray[],
                                                            int ldb,
                                                            int *info,
                                                            int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgetrsBatched( cublasHandle_t handle,
                                                           cublasOperation_t trans,
                                                           int n,
                                                           int nrhs,
                                                           const double *Aarray[],
                                                           int lda,
                                                           const int *devIpiv,
                                                           double *Barray[],
                                                           int ldb,
                                                           int *info,
                                                           int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgetrsBatched( cublasHandle_t handle,
                                                            cublasOperation_t trans,
                                                            int n,
                                                            int nrhs,
                                                            const cuComplex *Aarray[],
                                                            int lda,
                                                            const int *devIpiv,
                                                            cuComplex *Barray[],
                                                            int ldb,
                                                            int *info,
                                                            int batchSize);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgetrsBatched( cublasHandle_t handle,
                                                            cublasOperation_t trans,
                                                            int n,
                                                            int nrhs,
                                                            const cuDoubleComplex *Aarray[],
                                                            int lda,
                                                            const int *devIpiv,
                                                            cuDoubleComplex *Barray[],
                                                            int ldb,
                                                            int *info,
                                                            int batchSize);




__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStrsmBatched( cublasHandle_t handle,
                                                          cublasSideMode_t side,
                                                          cublasFillMode_t uplo,
                                                          cublasOperation_t trans,
                                                          cublasDiagType_t diag,
                                                          int m,
                                                          int n,
                                                          const float *alpha,
                                                          const float *A[],
                                                          int lda,
                                                          float *B[],
                                                          int ldb,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtrsmBatched( cublasHandle_t handle,
                                                          cublasSideMode_t side,
                                                          cublasFillMode_t uplo,
                                                          cublasOperation_t trans,
                                                          cublasDiagType_t diag,
                                                          int m,
                                                          int n,
                                                          const double *alpha,
                                                          const double *A[],
                                                          int lda,
                                                          double *B[],
                                                          int ldb,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtrsmBatched( cublasHandle_t handle,
                                                          cublasSideMode_t side,
                                                          cublasFillMode_t uplo,
                                                          cublasOperation_t trans,
                                                          cublasDiagType_t diag,
                                                          int m,
                                                          int n,
                                                          const cuComplex *alpha,
                                                          const cuComplex *A[],
                                                          int lda,
                                                          cuComplex *B[],
                                                          int ldb,
                                                          int batchCount);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtrsmBatched( cublasHandle_t handle,
                                                          cublasSideMode_t side,
                                                          cublasFillMode_t uplo,
                                                          cublasOperation_t trans,
                                                          cublasDiagType_t diag,
                                                          int m,
                                                          int n,
                                                          const cuDoubleComplex *alpha,
                                                          const cuDoubleComplex *A[],
                                                          int lda,
                                                          cuDoubleComplex *B[],
                                                          int ldb,
                                                          int batchCount);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSmatinvBatched(cublasHandle_t handle,
                                                          int n,
                                                          const float *A[],
                                                          int lda,
                                                          float *Ainv[],
                                                          int lda_inv,
                                                          int *info,
                                                          int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDmatinvBatched(cublasHandle_t handle,
                                                          int n,
                                                          const double *A[],
                                                          int lda,
                                                          double *Ainv[],
                                                          int lda_inv,
                                                          int *info,
                                                          int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCmatinvBatched(cublasHandle_t handle,
                                                          int n,
                                                          const cuComplex *A[],
                                                          int lda,
                                                          cuComplex *Ainv[],
                                                          int lda_inv,
                                                          int *info,
                                                          int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZmatinvBatched(cublasHandle_t handle,
                                                          int n,
                                                          const cuDoubleComplex *A[],
                                                          int lda,
                                                          cuDoubleComplex *Ainv[],
                                                          int lda_inv,
                                                          int *info,
                                                          int batchSize);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgeqrfBatched( cublasHandle_t handle,
                                                           int m,
                                                           int n,
                                                           float *Aarray[],
                                                           int lda,
                                                           float *TauArray[],
                                                           int *info,
                                                           int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgeqrfBatched( cublasHandle_t handle,
                                                            int m,
                                                            int n,
                                                            double *Aarray[],
                                                            int lda,
                                                            double *TauArray[],
                                                            int *info,
                                                            int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgeqrfBatched( cublasHandle_t handle,
                                                            int m,
                                                            int n,
                                                            cuComplex *Aarray[],
                                                            int lda,
                                                            cuComplex *TauArray[],
                                                            int *info,
                                                            int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgeqrfBatched( cublasHandle_t handle,
                                                            int m,
                                                            int n,
                                                            cuDoubleComplex *Aarray[],
                                                            int lda,
                                                            cuDoubleComplex *TauArray[],
                                                            int *info,
                                                            int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSgelsBatched( cublasHandle_t handle,
                                                           cublasOperation_t trans,
                                                           int m,
                                                           int n,
                                                           int nrhs,
                                                           float *Aarray[],
                                                           int lda,
                                                           float *Carray[],
                                                           int ldc,
                                                           int *info,
                                                           int *devInfoArray,
                                                           int batchSize );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDgelsBatched( cublasHandle_t handle,
                                                           cublasOperation_t trans,
                                                           int m,
                                                           int n,
                                                           int nrhs,
                                                           double *Aarray[],
                                                           int lda,
                                                           double *Carray[],
                                                           int ldc,
                                                           int *info,
                                                           int *devInfoArray,
                                                           int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCgelsBatched( cublasHandle_t handle,
                                                           cublasOperation_t trans,
                                                           int m,
                                                           int n,
                                                           int nrhs,
                                                           cuComplex *Aarray[],
                                                           int lda,
                                                           cuComplex *Carray[],
                                                           int ldc,
                                                           int *info,
                                                           int *devInfoArray,
                                                           int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZgelsBatched( cublasHandle_t handle,
                                                           cublasOperation_t trans,
                                                           int m,
                                                           int n,
                                                           int nrhs,
                                                           cuDoubleComplex *Aarray[],
                                                           int lda,
                                                           cuDoubleComplex *Carray[],
                                                           int ldc,
                                                           int *info,
                                                           int *devInfoArray,
                                                           int batchSize);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasSdgmm(cublasHandle_t handle,
                                                  cublasSideMode_t mode,
                                                  int m,
                                                  int n,
                                                  const float *A,
                                                  int lda,
                                                  const float *x,
                                                  int incx,
                                                  float *C,
                                                  int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDdgmm(cublasHandle_t handle,
                                                  cublasSideMode_t mode,
                                                  int m,
                                                  int n,
                                                  const double *A,
                                                  int lda,
                                                  const double *x,
                                                  int incx,
                                                  double *C,
                                                  int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCdgmm(cublasHandle_t handle,
                                                  cublasSideMode_t mode,
                                                  int m,
                                                  int n,
                                                  const cuComplex *A,
                                                  int lda,
                                                  const cuComplex *x,
                                                  int incx,
                                                  cuComplex *C,
                                                  int ldc);

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZdgmm(cublasHandle_t handle,
                                                  cublasSideMode_t mode,
                                                  int m,
                                                  int n,
                                                  const cuDoubleComplex *A,
                                                  int lda,
                                                  const cuDoubleComplex *x,
                                                  int incx,
                                                  cuDoubleComplex *C,
                                                  int ldc);


__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStpttr ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const float *AP,
                                                     float *A,
                                                     int lda );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtpttr ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const double *AP,
                                                     double *A,
                                                     int lda );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtpttr ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const cuComplex *AP,
                                                     cuComplex *A,
                                                     int lda );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtpttr ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const cuDoubleComplex *AP,
                                                     cuDoubleComplex *A,
                                                     int lda );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasStrttp ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const float *A,
                                                     int lda,
                                                     float *AP );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasDtrttp ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const double *A,
                                                     int lda,
                                                     double *AP );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasCtrttp ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const cuComplex *A,
                                                     int lda,
                                                     cuComplex *AP );

__attribute__((host)) __attribute__((device)) cublasStatus_t cublasZtrttp ( cublasHandle_t handle,
                                                     cublasFillMode_t uplo,
                                                     int n,
                                                     const cuDoubleComplex *A,
                                                     int lda,
                                                     cuDoubleComplex *AP );


}
# 66 "/usr/local/cuda/include/cublas_v2.h" 2
# 4 "./src/maxpool_layer_kernels.cu" 2

extern "C" {
# 1 "./src/maxpool_layer.h" 1



# 1 "./src/image.h" 1




# 1 "/usr/include/stdio.h" 1 3 4
# 29 "/usr/include/stdio.h" 3 4

# 29 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 44 "/usr/include/stdio.h" 3 4
struct _IO_FILE;



typedef struct _IO_FILE FILE;





# 64 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 74 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 31 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 15 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 16 "/usr/include/_G_config.h" 2 3 4




# 1 "/usr/include/wchar.h" 1 3 4
# 82 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {

    unsigned int __wch;



    char __wchb[4];
  } __value;
} __mbstate_t;
# 21 "/usr/include/_G_config.h" 2 3 4
typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 32 "/usr/include/libio.h" 2 3 4
# 49 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 50 "/usr/include/libio.h" 2 3 4
# 144 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;





typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 173 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 241 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 289 "/usr/include/libio.h" 3 4
  __off64_t _offset;







  void *__pad1;
  void *__pad2;
  void *__pad3;
  void *__pad4;

  size_t __pad5;
  int _mode;

  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];

};





struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 333 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
     size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;

struct _IO_cookie_file;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
        void *__cookie, _IO_cookie_io_functions_t __fns);




extern "C" {


extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
# 429 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();

extern int _IO_peekc_locked (_IO_FILE *__fp);





extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 459 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
   __gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
    __gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);

extern void _IO_free_backup_area (_IO_FILE *) throw ();
# 521 "/usr/include/libio.h" 3 4
}
# 75 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
# 108 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;
# 164 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 165 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;







extern int remove (const char *__filename) throw ();

extern int rename (const char *__old, const char *__new) throw ();




extern int renameat (int __oldfd, const char *__old, int __newfd,
       const char *__new) throw ();








extern FILE *tmpfile (void) ;
# 205 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;



extern char *tmpnam (char *__s) throw () ;





extern char *tmpnam_r (char *__s) throw () ;
# 227 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
     throw () __attribute__ ((__malloc__)) ;








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 252 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 262 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);









extern FILE *fopen (const char *__restrict __filename,
      const char *__restrict __modes) ;




extern FILE *freopen (const char *__restrict __filename,
        const char *__restrict __modes,
        FILE *__restrict __stream) ;
# 295 "/usr/include/stdio.h" 3 4


extern FILE *fopen64 (const char *__restrict __filename,
        const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
   const char *__restrict __modes,
   FILE *__restrict __stream) ;




extern FILE *fdopen (int __fd, const char *__modes) throw () ;





extern FILE *fopencookie (void *__restrict __magic_cookie,
     const char *__restrict __modes,
     _IO_cookie_io_functions_t __io_funcs) throw () ;




extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
  throw () ;




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) throw ();





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) throw ();


extern void setlinebuf (FILE *__stream) throw ();








extern int fprintf (FILE *__restrict __stream,
      const char *__restrict __format, ...);




extern int printf (const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
      const char *__restrict __format, ...) throw ();





extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
       __gnuc_va_list __arg);




extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, const char *__restrict __format,
       __gnuc_va_list __arg) throw ();





extern int snprintf (char *__restrict __s, size_t __maxlen,
       const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));






extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
        __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
         const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
       const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;




extern int vdprintf (int __fd, const char *__restrict __fmt,
       __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
     const char *__restrict __format, ...) ;




extern int scanf (const char *__restrict __format, ...) ;

extern int sscanf (const char *__restrict __s,
     const char *__restrict __format, ...) throw ();
# 463 "/usr/include/stdio.h" 3 4








extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0))) ;





extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) ;


extern int vsscanf (const char *__restrict __s,
      const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
# 522 "/usr/include/stdio.h" 3 4









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 550 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 561 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 594 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
     ;
# 638 "/usr/include/stdio.h" 3 4
extern char *gets (char *__s) __attribute__ ((__deprecated__));


# 649 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) ;
# 665 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
          size_t *__restrict __n, int __delimiter,
          FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
        size_t *__restrict __n, int __delimiter,
        FILE *__restrict __stream) ;







extern __ssize_t getline (char **__restrict __lineptr,
       size_t *__restrict __n,
       FILE *__restrict __stream) ;








extern int fputs (const char *__restrict __s, FILE *__restrict __stream);





extern int puts (const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream) ;




extern size_t fwrite (const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s);

# 726 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
      FILE *__restrict __stream);
# 737 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream) ;




extern void rewind (FILE *__stream);

# 773 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);




extern __off_t ftello (FILE *__stream) ;
# 792 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 815 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);




extern void clearerr (FILE *__stream) throw ();

extern int feof (FILE *__stream) throw () ;

extern int ferror (FILE *__stream) throw () ;




extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;








extern void perror (const char *__s);






# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];


extern int _sys_nerr;
extern const char *const _sys_errlist[];
# 854 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw () ;




extern int fileno_unlocked (FILE *__stream) throw () ;
# 872 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       const char *__restrict __format,
       __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw () ;


extern void funlockfile (FILE *__stream) throw ();
# 942 "/usr/include/stdio.h" 3 4
}
# 6 "./src/image.h" 2
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/float.h" 1 3 4
# 7 "./src/image.h" 2


# 1 "./src/box.h" 1


# 1 "include/darknet.h" 1





# 1 "/usr/include/pthread.h" 1 3 4
# 23 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 28 "/usr/include/sched.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 29 "/usr/include/sched.h" 2 3 4
# 43 "/usr/include/sched.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/sched.h" 1 3 4
# 72 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
struct sched_param
  {
    int __sched_priority;
  };

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack,
    int __flags, void *__arg, ...) throw ();


extern int unshare (int __flags) throw ();


extern int sched_getcpu (void) throw ();


extern int setns (int __fd, int __nstype) throw ();



}







struct __sched_param
  {
    int __sched_priority;
  };
# 118 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
typedef unsigned long int __cpu_mask;






typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 201 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4
extern "C" {

extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
  throw ();
extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
extern void __sched_cpufree (cpu_set_t *__set) throw ();

}
# 44 "/usr/include/sched.h" 2 3 4




extern "C" {


extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
     throw ();


extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();


extern int sched_setscheduler (__pid_t __pid, int __policy,
          const struct sched_param *__param) throw ();


extern int sched_getscheduler (__pid_t __pid) throw ();


extern int sched_yield (void) throw ();


extern int sched_get_priority_max (int __algorithm) throw ();


extern int sched_get_priority_min (int __algorithm) throw ();


extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
# 118 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         const cpu_set_t *__cpuset) throw ();


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) throw ();


}
# 24 "/usr/include/pthread.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 29 "/usr/include/pthread.h" 2 3 4



enum
{
  PTHREAD_CREATE_JOINABLE,

  PTHREAD_CREATE_DETACHED

};



enum
{
  PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_ADAPTIVE_NP

  ,
  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL



  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

};




enum
{
  PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
  PTHREAD_MUTEX_ROBUST,
  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
};





enum
{
  PTHREAD_PRIO_NONE,
  PTHREAD_PRIO_INHERIT,
  PTHREAD_PRIO_PROTECT
};
# 114 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
};
# 155 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};



enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};



enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};
# 190 "/usr/include/pthread.h" 3 4
struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};


enum
{
  PTHREAD_CANCEL_ENABLE,

  PTHREAD_CANCEL_DISABLE

};
enum
{
  PTHREAD_CANCEL_DEFERRED,

  PTHREAD_CANCEL_ASYNCHRONOUS

};
# 228 "/usr/include/pthread.h" 3 4
extern "C" {




extern int pthread_create (pthread_t *__restrict __newthread,
      const pthread_attr_t *__restrict __attr,
      void *(*__start_routine) (void *),
      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));





extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));







extern int pthread_join (pthread_t __th, void **__thread_return);




extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();







extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
     const struct timespec *__abstime);






extern int pthread_detach (pthread_t __th) throw ();



extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
  throw () __attribute__ ((__const__));







extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_destroy (pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
     int *__detachstate)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
     int __detachstate)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
          size_t *__guardsize)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
          size_t __guardsize)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
           struct sched_param *__restrict __param)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
           const struct sched_param *__restrict
           __param) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
     __attr, int *__restrict __policy)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
      __attr, int *__restrict __inherit)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
      int __inherit)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
      int *__restrict __scope)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
          __attr, void **__restrict __stackaddr)
     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));





extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
          void *__stackaddr)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));


extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
          __attr, size_t *__restrict __stacksize)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
          size_t __stacksize)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize)
     throw () __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));





extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
     size_t __cpusetsize,
     const cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
     size_t __cpusetsize,
     cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (1, 3)));


extern int pthread_getattr_default_np (pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));




extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
     throw () __attribute__ ((__nonnull__ (2)));







extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
      const struct sched_param *__param)
     throw () __attribute__ ((__nonnull__ (3)));


extern int pthread_getschedparam (pthread_t __target_thread,
      int *__restrict __policy,
      struct sched_param *__restrict __param)
     throw () __attribute__ ((__nonnull__ (2, 3)));


extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
     throw ();




extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
          size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));


extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
     throw () __attribute__ ((__nonnull__ (2)));





extern int pthread_getconcurrency (void) throw ();


extern int pthread_setconcurrency (int __level) throw ();







extern int pthread_yield (void) throw ();




extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
       const cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (3)));


extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
       cpu_set_t *__cpuset)
     throw () __attribute__ ((__nonnull__ (3)));
# 494 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 506 "/usr/include/pthread.h" 3 4
extern int pthread_setcancelstate (int __state, int *__oldstate);



extern int pthread_setcanceltype (int __type, int *__oldtype);


extern int pthread_cancel (pthread_t __th);




extern void pthread_testcancel (void);




typedef struct
{
  struct
  {
    __jmp_buf __cancel_jmp_buf;
    int __mask_was_saved;
  } __cancel_jmp_buf[1];
  void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 540 "/usr/include/pthread.h" 3 4
struct __pthread_cleanup_frame
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;
};




class __pthread_cleanup_class
{
  void (*__cancel_routine) (void *);
  void *__cancel_arg;
  int __do_it;
  int __cancel_type;

 public:
  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
  void __setdoit (int __newval) { __do_it = __newval; }
  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
        &__cancel_type); }
  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
};
# 742 "/usr/include/pthread.h" 3 4
struct __jmp_buf_tag;
extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();





extern int pthread_mutex_init (pthread_mutex_t *__mutex,
          const pthread_mutexattr_t *__mutexattr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
        const struct timespec *__restrict
        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
      __restrict __mutex,
      int *__restrict __prioceiling)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
      int __prioceiling,
      int *__restrict __old_ceiling)
     throw () __attribute__ ((__nonnull__ (1, 3)));




extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));
# 806 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
       __restrict __attr,
       int *__restrict __protocol)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
       int __protocol)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
          __restrict __attr,
          int *__restrict __prioceiling)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
          int __prioceiling)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
     int *__robustness)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
        int *__robustness)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
     int __robustness)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
        int __robustness)
     throw () __attribute__ ((__nonnull__ (1)));
# 888 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    const pthread_rwlockattr_t *__restrict
    __attr) throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     throw () __attribute__ ((__nonnull__ (1)));





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
       int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pref)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
       int __pref) throw () __attribute__ ((__nonnull__ (1)));







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         const pthread_condattr_t *__restrict __cond_attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_destroy (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_signal (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_broadcast (pthread_cond_t *__cond)
     throw () __attribute__ ((__nonnull__ (1)));






extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
         pthread_mutex_t *__restrict __mutex)
     __attribute__ ((__nonnull__ (1, 2)));
# 1000 "/usr/include/pthread.h" 3 4
extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
       pthread_mutex_t *__restrict __mutex,
       const struct timespec *__restrict __abstime)
     __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_condattr_init (pthread_condattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_getpshared (const pthread_condattr_t *
     __restrict __attr,
     int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
     int __pshared) throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_condattr_getclock (const pthread_condattr_t *
          __restrict __attr,
          __clockid_t *__restrict __clock_id)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
          __clockid_t __clock_id)
     throw () __attribute__ ((__nonnull__ (1)));
# 1044 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_lock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
     throw () __attribute__ ((__nonnull__ (1)));






extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
     throw () __attribute__ ((__nonnull__ (1)));



extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
        int __pshared)
     throw () __attribute__ ((__nonnull__ (1)));
# 1111 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
          void (*__destr_function) (void *))
     throw () __attribute__ ((__nonnull__ (1)));


extern int pthread_key_delete (pthread_key_t __key) throw ();


extern void *pthread_getspecific (pthread_key_t __key) throw ();


extern int pthread_setspecific (pthread_key_t __key,
    const void *__pointer) throw () ;




extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id)
     throw () __attribute__ ((__nonnull__ (2)));
# 1145 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) throw ();
# 1159 "/usr/include/pthread.h" 3 4
}
# 7 "include/darknet.h" 2
# 1 "/usr/include/unistd.h" 1 3 4
# 27 "/usr/include/unistd.h" 3 4
extern "C" {
# 205 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix_opt.h" 1 3 4
# 206 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/x86_64-linux-gnu/bits/environments.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/environments.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/environments.h" 2 3 4
# 210 "/usr/include/unistd.h" 2 3 4
# 229 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h" 1 3 4
# 230 "/usr/include/unistd.h" 2 3 4
# 270 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;






typedef __socklen_t socklen_t;
# 290 "/usr/include/unistd.h" 3 4
extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));




extern int euidaccess (const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));


extern int eaccess (const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));






extern int faccessat (int __fd, const char *__file, int __type, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) ;
# 337 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 348 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     throw ();






extern int close (int __fd);






extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;





extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
# 379 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
        __off_t __offset) ;






extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
         __off_t __offset) ;
# 407 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset) ;


extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
    __off64_t __offset) ;







extern int pipe (int __pipedes[2]) throw () ;




extern int pipe2 (int __pipedes[2], int __flags) throw () ;
# 435 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 447 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);







extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     throw ();






extern int usleep (__useconds_t __useconds);
# 472 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) ;



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;




extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) ;






extern int fchownat (int __fd, const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) ;



extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;



extern int fchdir (int __fd) throw () ;
# 514 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () ;





extern char *get_current_dir_name (void) throw ();







extern char *getwd (char *__buf)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;




extern int dup (int __fd) throw () ;


extern int dup2 (int __fd, int __fd2) throw ();




extern int dup3 (int __fd, int __fd2, int __flags) throw ();



extern char **__environ;

extern char **environ;





extern int execve (const char *__path, char *const __argv[],
     char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));




extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
     throw () __attribute__ ((__nonnull__ (2)));




extern int execv (const char *__path, char *const __argv[])
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int execle (const char *__path, const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int execl (const char *__path, const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int execvp (const char *__file, char *const __argv[])
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int execlp (const char *__file, const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int execvpe (const char *__file, char *const __argv[],
      char *const __envp[])
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern int nice (int __inc) throw () ;




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/x86_64-linux-gnu/bits/confname.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/bits/confname.h" 3 4
enum
  {
    _PC_LINK_MAX,

    _PC_MAX_CANON,

    _PC_MAX_INPUT,

    _PC_NAME_MAX,

    _PC_PATH_MAX,

    _PC_PIPE_BUF,

    _PC_CHOWN_RESTRICTED,

    _PC_NO_TRUNC,

    _PC_VDISABLE,

    _PC_SYNC_IO,

    _PC_ASYNC_IO,

    _PC_PRIO_IO,

    _PC_SOCK_MAXBUF,

    _PC_FILESIZEBITS,

    _PC_REC_INCR_XFER_SIZE,

    _PC_REC_MAX_XFER_SIZE,

    _PC_REC_MIN_XFER_SIZE,

    _PC_REC_XFER_ALIGN,

    _PC_ALLOC_SIZE_MIN,

    _PC_SYMLINK_MAX,

    _PC_2_SYMLINKS

  };


enum
  {
    _SC_ARG_MAX,

    _SC_CHILD_MAX,

    _SC_CLK_TCK,

    _SC_NGROUPS_MAX,

    _SC_OPEN_MAX,

    _SC_STREAM_MAX,

    _SC_TZNAME_MAX,

    _SC_JOB_CONTROL,

    _SC_SAVED_IDS,

    _SC_REALTIME_SIGNALS,

    _SC_PRIORITY_SCHEDULING,

    _SC_TIMERS,

    _SC_ASYNCHRONOUS_IO,

    _SC_PRIORITIZED_IO,

    _SC_SYNCHRONIZED_IO,

    _SC_FSYNC,

    _SC_MAPPED_FILES,

    _SC_MEMLOCK,

    _SC_MEMLOCK_RANGE,

    _SC_MEMORY_PROTECTION,

    _SC_MESSAGE_PASSING,

    _SC_SEMAPHORES,

    _SC_SHARED_MEMORY_OBJECTS,

    _SC_AIO_LISTIO_MAX,

    _SC_AIO_MAX,

    _SC_AIO_PRIO_DELTA_MAX,

    _SC_DELAYTIMER_MAX,

    _SC_MQ_OPEN_MAX,

    _SC_MQ_PRIO_MAX,

    _SC_VERSION,

    _SC_PAGESIZE,


    _SC_RTSIG_MAX,

    _SC_SEM_NSEMS_MAX,

    _SC_SEM_VALUE_MAX,

    _SC_SIGQUEUE_MAX,

    _SC_TIMER_MAX,




    _SC_BC_BASE_MAX,

    _SC_BC_DIM_MAX,

    _SC_BC_SCALE_MAX,

    _SC_BC_STRING_MAX,

    _SC_COLL_WEIGHTS_MAX,

    _SC_EQUIV_CLASS_MAX,

    _SC_EXPR_NEST_MAX,

    _SC_LINE_MAX,

    _SC_RE_DUP_MAX,

    _SC_CHARCLASS_NAME_MAX,


    _SC_2_VERSION,

    _SC_2_C_BIND,

    _SC_2_C_DEV,

    _SC_2_FORT_DEV,

    _SC_2_FORT_RUN,

    _SC_2_SW_DEV,

    _SC_2_LOCALEDEF,


    _SC_PII,

    _SC_PII_XTI,

    _SC_PII_SOCKET,

    _SC_PII_INTERNET,

    _SC_PII_OSI,

    _SC_POLL,

    _SC_SELECT,

    _SC_UIO_MAXIOV,

    _SC_IOV_MAX = _SC_UIO_MAXIOV,

    _SC_PII_INTERNET_STREAM,

    _SC_PII_INTERNET_DGRAM,

    _SC_PII_OSI_COTS,

    _SC_PII_OSI_CLTS,

    _SC_PII_OSI_M,

    _SC_T_IOV_MAX,



    _SC_THREADS,

    _SC_THREAD_SAFE_FUNCTIONS,

    _SC_GETGR_R_SIZE_MAX,

    _SC_GETPW_R_SIZE_MAX,

    _SC_LOGIN_NAME_MAX,

    _SC_TTY_NAME_MAX,

    _SC_THREAD_DESTRUCTOR_ITERATIONS,

    _SC_THREAD_KEYS_MAX,

    _SC_THREAD_STACK_MIN,

    _SC_THREAD_THREADS_MAX,

    _SC_THREAD_ATTR_STACKADDR,

    _SC_THREAD_ATTR_STACKSIZE,

    _SC_THREAD_PRIORITY_SCHEDULING,

    _SC_THREAD_PRIO_INHERIT,

    _SC_THREAD_PRIO_PROTECT,

    _SC_THREAD_PROCESS_SHARED,


    _SC_NPROCESSORS_CONF,

    _SC_NPROCESSORS_ONLN,

    _SC_PHYS_PAGES,

    _SC_AVPHYS_PAGES,

    _SC_ATEXIT_MAX,

    _SC_PASS_MAX,


    _SC_XOPEN_VERSION,

    _SC_XOPEN_XCU_VERSION,

    _SC_XOPEN_UNIX,

    _SC_XOPEN_CRYPT,

    _SC_XOPEN_ENH_I18N,

    _SC_XOPEN_SHM,


    _SC_2_CHAR_TERM,

    _SC_2_C_VERSION,

    _SC_2_UPE,


    _SC_XOPEN_XPG2,

    _SC_XOPEN_XPG3,

    _SC_XOPEN_XPG4,


    _SC_CHAR_BIT,

    _SC_CHAR_MAX,

    _SC_CHAR_MIN,

    _SC_INT_MAX,

    _SC_INT_MIN,

    _SC_LONG_BIT,

    _SC_WORD_BIT,

    _SC_MB_LEN_MAX,

    _SC_NZERO,

    _SC_SSIZE_MAX,

    _SC_SCHAR_MAX,

    _SC_SCHAR_MIN,

    _SC_SHRT_MAX,

    _SC_SHRT_MIN,

    _SC_UCHAR_MAX,

    _SC_UINT_MAX,

    _SC_ULONG_MAX,

    _SC_USHRT_MAX,


    _SC_NL_ARGMAX,

    _SC_NL_LANGMAX,

    _SC_NL_MSGMAX,

    _SC_NL_NMAX,

    _SC_NL_SETMAX,

    _SC_NL_TEXTMAX,


    _SC_XBS5_ILP32_OFF32,

    _SC_XBS5_ILP32_OFFBIG,

    _SC_XBS5_LP64_OFF64,

    _SC_XBS5_LPBIG_OFFBIG,


    _SC_XOPEN_LEGACY,

    _SC_XOPEN_REALTIME,

    _SC_XOPEN_REALTIME_THREADS,


    _SC_ADVISORY_INFO,

    _SC_BARRIERS,

    _SC_BASE,

    _SC_C_LANG_SUPPORT,

    _SC_C_LANG_SUPPORT_R,

    _SC_CLOCK_SELECTION,

    _SC_CPUTIME,

    _SC_THREAD_CPUTIME,

    _SC_DEVICE_IO,

    _SC_DEVICE_SPECIFIC,

    _SC_DEVICE_SPECIFIC_R,

    _SC_FD_MGMT,

    _SC_FIFO,

    _SC_PIPE,

    _SC_FILE_ATTRIBUTES,

    _SC_FILE_LOCKING,

    _SC_FILE_SYSTEM,

    _SC_MONOTONIC_CLOCK,

    _SC_MULTI_PROCESS,

    _SC_SINGLE_PROCESS,

    _SC_NETWORKING,

    _SC_READER_WRITER_LOCKS,

    _SC_SPIN_LOCKS,

    _SC_REGEXP,

    _SC_REGEX_VERSION,

    _SC_SHELL,

    _SC_SIGNALS,

    _SC_SPAWN,

    _SC_SPORADIC_SERVER,

    _SC_THREAD_SPORADIC_SERVER,

    _SC_SYSTEM_DATABASE,

    _SC_SYSTEM_DATABASE_R,

    _SC_TIMEOUTS,

    _SC_TYPED_MEMORY_OBJECTS,

    _SC_USER_GROUPS,

    _SC_USER_GROUPS_R,

    _SC_2_PBS,

    _SC_2_PBS_ACCOUNTING,

    _SC_2_PBS_LOCATE,

    _SC_2_PBS_MESSAGE,

    _SC_2_PBS_TRACK,

    _SC_SYMLOOP_MAX,

    _SC_STREAMS,

    _SC_2_PBS_CHECKPOINT,


    _SC_V6_ILP32_OFF32,

    _SC_V6_ILP32_OFFBIG,

    _SC_V6_LP64_OFF64,

    _SC_V6_LPBIG_OFFBIG,


    _SC_HOST_NAME_MAX,

    _SC_TRACE,

    _SC_TRACE_EVENT_FILTER,

    _SC_TRACE_INHERIT,

    _SC_TRACE_LOG,


    _SC_LEVEL1_ICACHE_SIZE,

    _SC_LEVEL1_ICACHE_ASSOC,

    _SC_LEVEL1_ICACHE_LINESIZE,

    _SC_LEVEL1_DCACHE_SIZE,

    _SC_LEVEL1_DCACHE_ASSOC,

    _SC_LEVEL1_DCACHE_LINESIZE,

    _SC_LEVEL2_CACHE_SIZE,

    _SC_LEVEL2_CACHE_ASSOC,

    _SC_LEVEL2_CACHE_LINESIZE,

    _SC_LEVEL3_CACHE_SIZE,

    _SC_LEVEL3_CACHE_ASSOC,

    _SC_LEVEL3_CACHE_LINESIZE,

    _SC_LEVEL4_CACHE_SIZE,

    _SC_LEVEL4_CACHE_ASSOC,

    _SC_LEVEL4_CACHE_LINESIZE,



    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,

    _SC_RAW_SOCKETS,


    _SC_V7_ILP32_OFF32,

    _SC_V7_ILP32_OFFBIG,

    _SC_V7_LP64_OFF64,

    _SC_V7_LPBIG_OFFBIG,


    _SC_SS_REPL_MAX,


    _SC_TRACE_EVENT_NAME_MAX,

    _SC_TRACE_NAME_MAX,

    _SC_TRACE_SYS_MAX,

    _SC_TRACE_USER_EVENT_MAX,


    _SC_XOPEN_STREAMS,


    _SC_THREAD_ROBUST_PRIO_INHERIT,

    _SC_THREAD_ROBUST_PRIO_PROTECT

  };


enum
  {
    _CS_PATH,


    _CS_V6_WIDTH_RESTRICTED_ENVS,



    _CS_GNU_LIBC_VERSION,

    _CS_GNU_LIBPTHREAD_VERSION,


    _CS_V5_WIDTH_RESTRICTED_ENVS,



    _CS_V7_WIDTH_RESTRICTED_ENVS,



    _CS_LFS_CFLAGS = 1000,

    _CS_LFS_LDFLAGS,

    _CS_LFS_LIBS,

    _CS_LFS_LINTFLAGS,

    _CS_LFS64_CFLAGS,

    _CS_LFS64_LDFLAGS,

    _CS_LFS64_LIBS,

    _CS_LFS64_LINTFLAGS,


    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,

    _CS_XBS5_ILP32_OFF32_LDFLAGS,

    _CS_XBS5_ILP32_OFF32_LIBS,

    _CS_XBS5_ILP32_OFF32_LINTFLAGS,

    _CS_XBS5_ILP32_OFFBIG_CFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LIBS,

    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,

    _CS_XBS5_LP64_OFF64_CFLAGS,

    _CS_XBS5_LP64_OFF64_LDFLAGS,

    _CS_XBS5_LP64_OFF64_LIBS,

    _CS_XBS5_LP64_OFF64_LINTFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LIBS,

    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LIBS,

    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V6_LP64_OFF64_CFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LIBS,

    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LIBS,

    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V7_LP64_OFF64_CFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LIBS,

    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,


    _CS_V6_ENV,

    _CS_V7_ENV

  };
# 613 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (const char *__path, int __name)
     throw () __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) throw ();


extern long int sysconf (int __name) throw ();



extern size_t confstr (int __name, char *__buf, size_t __len) throw ();




extern __pid_t getpid (void) throw ();


extern __pid_t getppid (void) throw ();


extern __pid_t getpgrp (void) throw ();


extern __pid_t __getpgid (__pid_t __pid) throw ();

extern __pid_t getpgid (__pid_t __pid) throw ();






extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
# 663 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();






extern __pid_t setsid (void) throw ();



extern __pid_t getsid (__pid_t __pid) throw ();



extern __uid_t getuid (void) throw ();


extern __uid_t geteuid (void) throw ();


extern __gid_t getgid (void) throw ();


extern __gid_t getegid (void) throw ();




extern int getgroups (int __size, __gid_t __list[]) throw () ;



extern int group_member (__gid_t __gid) throw ();






extern int setuid (__uid_t __uid) throw () ;




extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;




extern int seteuid (__uid_t __uid) throw () ;






extern int setgid (__gid_t __gid) throw () ;




extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;




extern int setegid (__gid_t __gid) throw () ;





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     throw ();



extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
     throw ();



extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
     throw () ;



extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
     throw () ;






extern __pid_t fork (void) throw ();







extern __pid_t vfork (void) throw ();





extern char *ttyname (int __fd) throw ();



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) ;



extern int isatty (int __fd) throw ();





extern int ttyslot (void) throw ();




extern int link (const char *__from, const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) ;




extern int linkat (int __fromfd, const char *__from, int __tofd,
     const char *__to, int __flags)
     throw () __attribute__ ((__nonnull__ (2, 4))) ;




extern int symlink (const char *__from, const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) ;




extern ssize_t readlink (const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (1, 2))) ;




extern int symlinkat (const char *__from, int __tofd,
        const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;


extern ssize_t readlinkat (int __fd, const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (2, 3))) ;



extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));



extern int unlinkat (int __fd, const char *__name, int __flag)
     throw () __attribute__ ((__nonnull__ (2)));



extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) throw ();


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));




extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
# 874 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 48 "/usr/include/getopt.h" 3 4
extern "C" {
# 57 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 71 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 150 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       throw ();
# 185 "/usr/include/getopt.h" 3 4
}
# 875 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));






extern int sethostname (const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) ;



extern int sethostid (long int __id) throw () ;





extern int getdomainname (char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) ;





extern int vhangup (void) throw ();


extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;







extern int profil (unsigned short int *__sample_buffer, size_t __size,
     size_t __offset, unsigned int __scale)
     throw () __attribute__ ((__nonnull__ (1)));





extern int acct (const char *__name) throw ();



extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();





extern int daemon (int __nochdir, int __noclose) throw () ;






extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;



extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));







extern int fsync (int __fd);





extern int syncfs (int __fd) throw ();






extern long int gethostid (void);


extern void sync (void) throw ();





extern int getpagesize (void) throw () __attribute__ ((__const__));




extern int getdtablesize (void) throw ();
# 996 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 1008 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 1019 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () ;
# 1029 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
# 1040 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () ;





extern void *sbrk (intptr_t __delta) throw ();
# 1061 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1084 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1094 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1115 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes);







extern char *crypt (const char *__key, const char *__salt)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern void encrypt (char *__glibc_block, int __edflag)
     throw () __attribute__ ((__nonnull__ (1)));






extern void swab (const void *__restrict __from, void *__restrict __to,
    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
# 1154 "/usr/include/unistd.h" 3 4
}
# 8 "include/darknet.h" 2



# 10 "include/darknet.h"
extern int gpu_index;
# 20 "include/darknet.h"
# 1 "/usr/include/cudnn.h" 1 3 4
# 63 "/usr/include/cudnn.h" 3 4
# 1 "/usr/local/cuda/include/driver_types.h" 1 3 4
# 64 "/usr/include/cudnn.h" 2 3 4
# 75 "/usr/include/cudnn.h" 3 4

# 75 "/usr/include/cudnn.h" 3 4
extern "C" {


struct cudnnContext;
typedef struct cudnnContext *cudnnHandle_t;

size_t cudnnGetVersion(void);


size_t cudnnGetCudartVersion(void);




typedef enum
{
    CUDNN_STATUS_SUCCESS = 0,
    CUDNN_STATUS_NOT_INITIALIZED = 1,
    CUDNN_STATUS_ALLOC_FAILED = 2,
    CUDNN_STATUS_BAD_PARAM = 3,
    CUDNN_STATUS_INTERNAL_ERROR = 4,
    CUDNN_STATUS_INVALID_VALUE = 5,
    CUDNN_STATUS_ARCH_MISMATCH = 6,
    CUDNN_STATUS_MAPPING_ERROR = 7,
    CUDNN_STATUS_EXECUTION_FAILED = 8,
    CUDNN_STATUS_NOT_SUPPORTED = 9,
    CUDNN_STATUS_LICENSE_ERROR = 10,
    CUDNN_STATUS_RUNTIME_PREREQUISITE_MISSING = 11,
    CUDNN_STATUS_RUNTIME_IN_PROGRESS = 12,
    CUDNN_STATUS_RUNTIME_FP_OVERFLOW = 13,
} cudnnStatus_t;


const char * cudnnGetErrorString(cudnnStatus_t status);


typedef struct cudnnRuntimeTag_t cudnnRuntimeTag_t;

typedef enum
{
    CUDNN_ERRQUERY_RAWCODE = 0,
    CUDNN_ERRQUERY_NONBLOCKING = 1,
    CUDNN_ERRQUERY_BLOCKING = 2,
} cudnnErrQueryMode_t;

cudnnStatus_t cudnnQueryRuntimeError(
                                cudnnHandle_t handle,
                                cudnnStatus_t *rstatus,
                                cudnnErrQueryMode_t mode,
                                cudnnRuntimeTag_t *tag );
# 137 "/usr/include/cudnn.h" 3 4
cudnnStatus_t cudnnGetProperty(libraryPropertyType type, int *value);

cudnnStatus_t cudnnCreate (cudnnHandle_t *handle);
cudnnStatus_t cudnnDestroy (cudnnHandle_t handle);
cudnnStatus_t cudnnSetStream (cudnnHandle_t handle, cudaStream_t streamId);
cudnnStatus_t cudnnGetStream (cudnnHandle_t handle, cudaStream_t *streamId);


typedef struct cudnnTensorStruct* cudnnTensorDescriptor_t;
typedef struct cudnnConvolutionStruct* cudnnConvolutionDescriptor_t;
typedef struct cudnnPoolingStruct* cudnnPoolingDescriptor_t;
typedef struct cudnnFilterStruct* cudnnFilterDescriptor_t;
typedef struct cudnnLRNStruct* cudnnLRNDescriptor_t;
typedef struct cudnnActivationStruct* cudnnActivationDescriptor_t;
typedef struct cudnnSpatialTransformerStruct* cudnnSpatialTransformerDescriptor_t;
typedef struct cudnnOpTensorStruct* cudnnOpTensorDescriptor_t;
typedef struct cudnnReduceTensorStruct* cudnnReduceTensorDescriptor_t;
typedef struct cudnnCTCLossStruct* cudnnCTCLossDescriptor_t;



typedef enum
{
    CUDNN_DATA_FLOAT = 0,
    CUDNN_DATA_DOUBLE = 1,
    CUDNN_DATA_HALF = 2,
    CUDNN_DATA_INT8 = 3,
    CUDNN_DATA_INT32 = 4,
    CUDNN_DATA_INT8x4 = 5
} cudnnDataType_t;




typedef enum {
    CUDNN_DEFAULT_MATH = 0,
    CUDNN_TENSOR_OP_MATH = 1,
} cudnnMathType_t;




typedef enum{
    CUDNN_NOT_PROPAGATE_NAN = 0,
    CUDNN_PROPAGATE_NAN = 1,
} cudnnNanPropagation_t;




typedef enum
{
    CUDNN_NON_DETERMINISTIC = 0,
    CUDNN_DETERMINISTIC = 1,
} cudnnDeterminism_t;





cudnnStatus_t cudnnCreateTensorDescriptor(
                                cudnnTensorDescriptor_t *tensorDesc );

typedef enum
{
    CUDNN_TENSOR_NCHW = 0,
    CUDNN_TENSOR_NHWC = 1,
    CUDNN_TENSOR_NCHW_VECT_C = 2
} cudnnTensorFormat_t;

cudnnStatus_t cudnnSetTensor4dDescriptor(
                                cudnnTensorDescriptor_t tensorDesc,
                                cudnnTensorFormat_t format,
                                cudnnDataType_t dataType,
                                int n,
                                int c,
                                int h,
                                int w );

cudnnStatus_t cudnnSetTensor4dDescriptorEx(
                                cudnnTensorDescriptor_t tensorDesc,
                                cudnnDataType_t dataType,
                                int n,
                                int c,
                                int h,
                                int w,
                                int nStride,
                                int cStride,
                                int hStride,
                                int wStride );

cudnnStatus_t cudnnGetTensor4dDescriptor(
                                const cudnnTensorDescriptor_t tensorDesc,
                                cudnnDataType_t *dataType,
                                int *n,
                                int *c,
                                int *h,
                                int *w,
                                int *nStride,
                                int *cStride,
                                int *hStride,
                                int *wStride );

cudnnStatus_t cudnnSetTensorNdDescriptor(
                                cudnnTensorDescriptor_t tensorDesc,
                                cudnnDataType_t dataType,
                                int nbDims,
                                const int dimA[],
                                const int strideA[] );

cudnnStatus_t cudnnSetTensorNdDescriptorEx(
                                cudnnTensorDescriptor_t tensorDesc,
                                cudnnTensorFormat_t format,
                                cudnnDataType_t dataType,
                                int nbDims,
                                const int dimA[] );

cudnnStatus_t cudnnGetTensorNdDescriptor(
                                const cudnnTensorDescriptor_t tensorDesc,
                                int nbDimsRequested,
                                cudnnDataType_t *dataType,
                                int *nbDims,
                                int dimA[],
                                int strideA[] );

cudnnStatus_t cudnnGetTensorSizeInBytes(
                                const cudnnTensorDescriptor_t tensorDesc,
                                size_t *size);
# 290 "/usr/include/cudnn.h" 3 4
cudnnStatus_t cudnnDestroyTensorDescriptor(
                                cudnnTensorDescriptor_t tensorDesc );



cudnnStatus_t cudnnTransformTensor(
                                cudnnHandle_t handle,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );



cudnnStatus_t cudnnAddTensor(
                                cudnnHandle_t handle,
                                const void *alpha,
                                const cudnnTensorDescriptor_t aDesc,
                                const void *A,
                                const void *beta,
                                const cudnnTensorDescriptor_t cDesc,
                                void *C );




typedef enum
{
    CUDNN_OP_TENSOR_ADD = 0,
    CUDNN_OP_TENSOR_MUL = 1,
    CUDNN_OP_TENSOR_MIN = 2,
    CUDNN_OP_TENSOR_MAX = 3,
    CUDNN_OP_TENSOR_SQRT = 4,
    CUDNN_OP_TENSOR_NOT = 5,
} cudnnOpTensorOp_t;

cudnnStatus_t cudnnCreateOpTensorDescriptor(
                                cudnnOpTensorDescriptor_t *opTensorDesc );

cudnnStatus_t cudnnSetOpTensorDescriptor(
                                cudnnOpTensorDescriptor_t opTensorDesc,
                                cudnnOpTensorOp_t opTensorOp,
                                cudnnDataType_t opTensorCompType,
                                cudnnNanPropagation_t opTensorNanOpt );

cudnnStatus_t cudnnGetOpTensorDescriptor(
                                const cudnnOpTensorDescriptor_t opTensorDesc,
                                cudnnOpTensorOp_t *opTensorOp,
                                cudnnDataType_t *opTensorCompType,
                                cudnnNanPropagation_t *opTensorNanOpt );

cudnnStatus_t cudnnDestroyOpTensorDescriptor(
                                cudnnOpTensorDescriptor_t opTensorDesc );



cudnnStatus_t cudnnOpTensor(
                                cudnnHandle_t handle,
                                const cudnnOpTensorDescriptor_t opTensorDesc,
                                const void *alpha1,
                                const cudnnTensorDescriptor_t aDesc,
                                const void *A,
                                const void *alpha2,
                                const cudnnTensorDescriptor_t bDesc,
                                const void *B,
                                const void *beta,
                                const cudnnTensorDescriptor_t cDesc,
                                void *C );




typedef enum
{
    CUDNN_REDUCE_TENSOR_ADD = 0,
    CUDNN_REDUCE_TENSOR_MUL = 1,
    CUDNN_REDUCE_TENSOR_MIN = 2,
    CUDNN_REDUCE_TENSOR_MAX = 3,
    CUDNN_REDUCE_TENSOR_AMAX = 4,
    CUDNN_REDUCE_TENSOR_AVG = 5,
    CUDNN_REDUCE_TENSOR_NORM1 = 6,
    CUDNN_REDUCE_TENSOR_NORM2 = 7,
    CUDNN_REDUCE_TENSOR_MUL_NO_ZEROS = 8,
} cudnnReduceTensorOp_t;




typedef enum
{
    CUDNN_REDUCE_TENSOR_NO_INDICES = 0,
    CUDNN_REDUCE_TENSOR_FLATTENED_INDICES = 1,
} cudnnReduceTensorIndices_t;





typedef enum
{
    CUDNN_32BIT_INDICES = 0,
    CUDNN_64BIT_INDICES = 1,
    CUDNN_16BIT_INDICES = 2,
    CUDNN_8BIT_INDICES = 3,
} cudnnIndicesType_t;

cudnnStatus_t cudnnCreateReduceTensorDescriptor(
                                cudnnReduceTensorDescriptor_t *reduceTensorDesc );

cudnnStatus_t cudnnSetReduceTensorDescriptor(
                                cudnnReduceTensorDescriptor_t reduceTensorDesc,
                                cudnnReduceTensorOp_t reduceTensorOp,
                                cudnnDataType_t reduceTensorCompType,
                                cudnnNanPropagation_t reduceTensorNanOpt,
                                cudnnReduceTensorIndices_t reduceTensorIndices,
                                cudnnIndicesType_t reduceTensorIndicesType );

cudnnStatus_t cudnnGetReduceTensorDescriptor(
                                const cudnnReduceTensorDescriptor_t reduceTensorDesc,
                                cudnnReduceTensorOp_t *reduceTensorOp,
                                cudnnDataType_t *reduceTensorCompType,
                                cudnnNanPropagation_t *reduceTensorNanOpt,
                                cudnnReduceTensorIndices_t *reduceTensorIndices,
                                cudnnIndicesType_t *reduceTensorIndicesType );

cudnnStatus_t cudnnDestroyReduceTensorDescriptor(
                                cudnnReduceTensorDescriptor_t reduceTensorDesc );


cudnnStatus_t cudnnGetReductionIndicesSize(
                                cudnnHandle_t handle,
                                const cudnnReduceTensorDescriptor_t reduceTensorDesc,
                                const cudnnTensorDescriptor_t aDesc,
                                const cudnnTensorDescriptor_t cDesc,
                                size_t *sizeInBytes );


cudnnStatus_t cudnnGetReductionWorkspaceSize(
                                cudnnHandle_t handle,
                                const cudnnReduceTensorDescriptor_t reduceTensorDesc,
                                const cudnnTensorDescriptor_t aDesc,
                                const cudnnTensorDescriptor_t cDesc,
                                size_t *sizeInBytes );




cudnnStatus_t cudnnReduceTensor(
                                cudnnHandle_t handle,
                                const cudnnReduceTensorDescriptor_t reduceTensorDesc,
                                void *indices,
                                size_t indicesSizeInBytes,
                                void *workspace,
                                size_t workspaceSizeInBytes,
                                const void *alpha,
                                const cudnnTensorDescriptor_t aDesc,
                                const void *A,
                                const void *beta,
                                const cudnnTensorDescriptor_t cDesc,
                                void *C );


cudnnStatus_t cudnnSetTensor(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y,
                                const void *valuePtr );


cudnnStatus_t cudnnScaleTensor(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y,
                                const void *alpha );




typedef enum
{
    CUDNN_CONVOLUTION = 0,
    CUDNN_CROSS_CORRELATION = 1
} cudnnConvolutionMode_t;



cudnnStatus_t cudnnCreateFilterDescriptor(
                                cudnnFilterDescriptor_t *filterDesc );


cudnnStatus_t cudnnSetFilter4dDescriptor(
                                cudnnFilterDescriptor_t filterDesc,
                                cudnnDataType_t dataType,
                                cudnnTensorFormat_t format,
                                int k,
                                int c,
                                int h,
                                int w );


cudnnStatus_t cudnnGetFilter4dDescriptor(
                                const cudnnFilterDescriptor_t filterDesc,
                                cudnnDataType_t *dataType,
                                cudnnTensorFormat_t *format,
                                int *k,
                                int *c,
                                int *h,
                                int *w );


cudnnStatus_t cudnnSetFilterNdDescriptor(
                                cudnnFilterDescriptor_t filterDesc,
                                cudnnDataType_t dataType,
                                cudnnTensorFormat_t format,
                                int nbDims,
                                const int filterDimA[] );

cudnnStatus_t cudnnGetFilterNdDescriptor(
                                const cudnnFilterDescriptor_t filterDesc,
                                int nbDimsRequested,
                                cudnnDataType_t *dataType,
                                cudnnTensorFormat_t *format,
                                int *nbDims,
                                int filterDimA[] );


cudnnStatus_t cudnnDestroyFilterDescriptor(
                                cudnnFilterDescriptor_t filterDesc );


cudnnStatus_t cudnnCreateConvolutionDescriptor(
                                cudnnConvolutionDescriptor_t *convDesc );

cudnnStatus_t cudnnSetConvolutionMathType( cudnnConvolutionDescriptor_t convDesc,
                                                       cudnnMathType_t mathType );

cudnnStatus_t cudnnGetConvolutionMathType( cudnnConvolutionDescriptor_t convDesc,
                                                       cudnnMathType_t *mathType );

cudnnStatus_t cudnnSetConvolutionGroupCount( cudnnConvolutionDescriptor_t convDesc,
                                                         int groupCount );

cudnnStatus_t cudnnGetConvolutionGroupCount( cudnnConvolutionDescriptor_t convDesc,
                                                         int *groupCount );

cudnnStatus_t cudnnSetConvolution2dDescriptor( cudnnConvolutionDescriptor_t convDesc,
                                                             int pad_h,
                                                             int pad_w,
                                                             int u,
                                                             int v,
                                                             int dilation_h,
                                                             int dilation_w,
                                                             cudnnConvolutionMode_t mode,
                                                             cudnnDataType_t computeType
                                                           );

cudnnStatus_t cudnnGetConvolution2dDescriptor( const cudnnConvolutionDescriptor_t convDesc,
                                                            int* pad_h,
                                                            int* pad_w,
                                                            int* u,
                                                            int* v,
                                                            int* dilation_h,
                                                            int* dilation_w,
                                                            cudnnConvolutionMode_t* mode,
                                                            cudnnDataType_t *computeType
                                                         );


cudnnStatus_t cudnnGetConvolution2dForwardOutputDim(
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t inputTensorDesc,
                                const cudnnFilterDescriptor_t filterDesc,
                                int *n,
                                int *c,
                                int *h,
                                int *w );


cudnnStatus_t cudnnSetConvolutionNdDescriptor(
                                cudnnConvolutionDescriptor_t convDesc,
                                int arrayLength,
                                const int padA[],
                                const int filterStrideA[],
                                const int dilationA[],
                                cudnnConvolutionMode_t mode,
                                cudnnDataType_t computeType );

cudnnStatus_t cudnnGetConvolutionNdDescriptor(
                                const cudnnConvolutionDescriptor_t convDesc,
                                int arrayLengthRequested,
                                int *arrayLength,
                                int padA[],
                                int strideA[],
                                int dilationA[],
                                cudnnConvolutionMode_t *mode,
                                cudnnDataType_t *computeType );



cudnnStatus_t cudnnGetConvolutionNdForwardOutputDim(
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t inputTensorDesc,
                                const cudnnFilterDescriptor_t filterDesc,
                                int nbDims,
                                int tensorOuputDimA[] );


cudnnStatus_t cudnnDestroyConvolutionDescriptor(
                                cudnnConvolutionDescriptor_t convDesc );



typedef enum
{
    CUDNN_CONVOLUTION_FWD_NO_WORKSPACE = 0,
    CUDNN_CONVOLUTION_FWD_PREFER_FASTEST = 1,
    CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT = 2,
} cudnnConvolutionFwdPreference_t;


typedef enum
{
    CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_GEMM = 0,
    CUDNN_CONVOLUTION_FWD_ALGO_IMPLICIT_PRECOMP_GEMM = 1,
    CUDNN_CONVOLUTION_FWD_ALGO_GEMM = 2,
    CUDNN_CONVOLUTION_FWD_ALGO_DIRECT = 3,
    CUDNN_CONVOLUTION_FWD_ALGO_FFT = 4,
    CUDNN_CONVOLUTION_FWD_ALGO_FFT_TILING = 5,
    CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD = 6,
    CUDNN_CONVOLUTION_FWD_ALGO_WINOGRAD_NONFUSED = 7,
    CUDNN_CONVOLUTION_FWD_ALGO_COUNT = 8
} cudnnConvolutionFwdAlgo_t;

typedef struct {
    cudnnConvolutionFwdAlgo_t algo;
    cudnnStatus_t status;
    float time;
    size_t memory;
    cudnnDeterminism_t determinism;
    cudnnMathType_t mathType;
    int reserved[3];
} cudnnConvolutionFwdAlgoPerf_t;

cudnnStatus_t cudnnGetConvolutionForwardAlgorithmMaxCount( cudnnHandle_t handle,
                                                                       int *count);

cudnnStatus_t cudnnFindConvolutionForwardAlgorithm(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t yDesc,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionFwdAlgoPerf_t *perfResults );

cudnnStatus_t cudnnFindConvolutionForwardAlgorithmEx(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnFilterDescriptor_t wDesc,
                                const void *w,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionFwdAlgoPerf_t *perfResults,
                                void *workSpace,
                                size_t workSpaceSizeInBytes );


cudnnStatus_t cudnnGetConvolutionForwardAlgorithm(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t yDesc,
                                cudnnConvolutionFwdPreference_t preference,
                                size_t memoryLimitInBytes,
                                cudnnConvolutionFwdAlgo_t *algo );


cudnnStatus_t cudnnGetConvolutionForwardAlgorithm_v7(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t srcDesc,
                                const cudnnFilterDescriptor_t filterDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t destDesc,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionFwdAlgoPerf_t *perfResults);






cudnnStatus_t cudnnGetConvolutionForwardWorkspaceSize(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t yDesc,
                                cudnnConvolutionFwdAlgo_t algo,
                                size_t *sizeInBytes );





cudnnStatus_t cudnnConvolutionForward(
                                cudnnHandle_t handle,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnFilterDescriptor_t wDesc,
                                const void *w,
                                const cudnnConvolutionDescriptor_t convDesc,
                                cudnnConvolutionFwdAlgo_t algo,
                                void *workSpace,
                                size_t workSpaceSizeInBytes,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );


cudnnStatus_t cudnnConvolutionBiasActivationForward(
                                cudnnHandle_t handle,
                                const void *alpha1,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnFilterDescriptor_t wDesc,
                                const void *w,
                                const cudnnConvolutionDescriptor_t convDesc,
                                cudnnConvolutionFwdAlgo_t algo,
                                void *workSpace,
                                size_t workSpaceSizeInBytes,
                                const void *alpha2,
                                const cudnnTensorDescriptor_t zDesc,
                                const void *z,
                                const cudnnTensorDescriptor_t biasDesc,
                                const void *bias,
                                const cudnnActivationDescriptor_t activationDesc,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );


cudnnStatus_t cudnnConvolutionBackwardBias(
                                cudnnHandle_t handle,
                                const void *alpha,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const void *beta,
                                const cudnnTensorDescriptor_t dbDesc,
                                void *db );



typedef enum
{
    CUDNN_CONVOLUTION_BWD_FILTER_NO_WORKSPACE = 0,
    CUDNN_CONVOLUTION_BWD_FILTER_PREFER_FASTEST = 1,
    CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT = 2,
} cudnnConvolutionBwdFilterPreference_t;

typedef enum
{
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0 = 0,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_1 = 1,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT = 2,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_3 = 3,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_WINOGRAD = 4,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_WINOGRAD_NONFUSED = 5,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT_TILING = 6,
    CUDNN_CONVOLUTION_BWD_FILTER_ALGO_COUNT = 7
} cudnnConvolutionBwdFilterAlgo_t;


typedef struct {
    cudnnConvolutionBwdFilterAlgo_t algo;
    cudnnStatus_t status;
    float time;
    size_t memory;
    cudnnDeterminism_t determinism;
    cudnnMathType_t mathType;
    int reserved[3];
} cudnnConvolutionBwdFilterAlgoPerf_t;

cudnnStatus_t cudnnGetConvolutionBackwardFilterAlgorithmMaxCount( cudnnHandle_t handle,
                                                                              int *count);

cudnnStatus_t cudnnFindConvolutionBackwardFilterAlgorithm(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const cudnnTensorDescriptor_t dyDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnFilterDescriptor_t dwDesc,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionBwdFilterAlgoPerf_t *perfResults );

cudnnStatus_t cudnnFindConvolutionBackwardFilterAlgorithmEx(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *y,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnFilterDescriptor_t dwDesc,
                                void *dw,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionBwdFilterAlgoPerf_t *perfResults,
                                void *workSpace,
                                size_t workSpaceSizeInBytes );

cudnnStatus_t cudnnGetConvolutionBackwardFilterAlgorithm(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const cudnnTensorDescriptor_t dyDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnFilterDescriptor_t dwDesc,
                                cudnnConvolutionBwdFilterPreference_t preference,
                                size_t memoryLimitInBytes,
                                cudnnConvolutionBwdFilterAlgo_t *algo );

cudnnStatus_t cudnnGetConvolutionBackwardFilterAlgorithm_v7(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t srcDesc,
                                const cudnnTensorDescriptor_t diffDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnFilterDescriptor_t gradDesc,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionBwdFilterAlgoPerf_t *perfResults);






cudnnStatus_t cudnnGetConvolutionBackwardFilterWorkspaceSize(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const cudnnTensorDescriptor_t dyDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnFilterDescriptor_t gradDesc,
                                cudnnConvolutionBwdFilterAlgo_t algo,
                                size_t *sizeInBytes );

cudnnStatus_t cudnnConvolutionBackwardFilter(
                                cudnnHandle_t handle,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnConvolutionDescriptor_t convDesc,
                                cudnnConvolutionBwdFilterAlgo_t algo,
                                void *workSpace,
                                size_t workSpaceSizeInBytes,
                                const void *beta,
                                const cudnnFilterDescriptor_t dwDesc,
                                void *dw );



typedef enum
{
    CUDNN_CONVOLUTION_BWD_DATA_NO_WORKSPACE = 0,
    CUDNN_CONVOLUTION_BWD_DATA_PREFER_FASTEST = 1,
    CUDNN_CONVOLUTION_BWD_DATA_SPECIFY_WORKSPACE_LIMIT = 2,
} cudnnConvolutionBwdDataPreference_t;

typedef enum
{
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_0 = 0,
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_1 = 1,
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT = 2,
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_FFT_TILING = 3,
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD = 4,
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_WINOGRAD_NONFUSED = 5,
    CUDNN_CONVOLUTION_BWD_DATA_ALGO_COUNT = 6
} cudnnConvolutionBwdDataAlgo_t;

typedef struct {
    cudnnConvolutionBwdDataAlgo_t algo;
    cudnnStatus_t status;
    float time;
    size_t memory;
    cudnnDeterminism_t determinism;
    cudnnMathType_t mathType;
    int reserved[3];
} cudnnConvolutionBwdDataAlgoPerf_t;

cudnnStatus_t cudnnGetConvolutionBackwardDataAlgorithmMaxCount( cudnnHandle_t handle,
                                                                            int *count);

cudnnStatus_t cudnnFindConvolutionBackwardDataAlgorithm(
                                cudnnHandle_t handle,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnTensorDescriptor_t dyDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t dxDesc,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionBwdDataAlgoPerf_t *perfResults );

cudnnStatus_t cudnnFindConvolutionBackwardDataAlgorithmEx(
                                cudnnHandle_t handle,
                                const cudnnFilterDescriptor_t wDesc,
                                const void *w,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionBwdDataAlgoPerf_t *perfResults,
                                void *workSpace,
                                size_t workSpaceSizeInBytes );

cudnnStatus_t cudnnGetConvolutionBackwardDataAlgorithm(
                                cudnnHandle_t handle,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnTensorDescriptor_t dyDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t dxDesc,
                                cudnnConvolutionBwdDataPreference_t preference,
                                size_t memoryLimitInBytes,
                                cudnnConvolutionBwdDataAlgo_t *algo );

cudnnStatus_t cudnnGetConvolutionBackwardDataAlgorithm_v7(
                                cudnnHandle_t handle,
                                const cudnnFilterDescriptor_t filterDesc,
                                const cudnnTensorDescriptor_t diffDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t gradDesc,
                                const int requestedAlgoCount,
                                int *returnedAlgoCount,
                                cudnnConvolutionBwdDataAlgoPerf_t *perfResults);


cudnnStatus_t cudnnGetConvolutionBackwardDataWorkspaceSize(
                                cudnnHandle_t handle,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnTensorDescriptor_t dyDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                const cudnnTensorDescriptor_t dxDesc,
                                cudnnConvolutionBwdDataAlgo_t algo,
                                size_t *sizeInBytes );


cudnnStatus_t cudnnConvolutionBackwardData(
                                cudnnHandle_t handle,
                                const void *alpha,
                                const cudnnFilterDescriptor_t wDesc,
                                const void *w,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnConvolutionDescriptor_t convDesc,
                                cudnnConvolutionBwdDataAlgo_t algo,
                                void *workSpace,
                                size_t workSpaceSizeInBytes,
                                const void *beta,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx );


cudnnStatus_t cudnnIm2Col(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnFilterDescriptor_t wDesc,
                                const cudnnConvolutionDescriptor_t convDesc,
                                void *colBuffer );





typedef enum
{
    CUDNN_SOFTMAX_FAST = 0,
    CUDNN_SOFTMAX_ACCURATE = 1,
    CUDNN_SOFTMAX_LOG = 2
} cudnnSoftmaxAlgorithm_t;

typedef enum
{
    CUDNN_SOFTMAX_MODE_INSTANCE = 0,
    CUDNN_SOFTMAX_MODE_CHANNEL = 1
} cudnnSoftmaxMode_t;




cudnnStatus_t cudnnSoftmaxForward(
                                cudnnHandle_t handle,
                                cudnnSoftmaxAlgorithm_t algo,
                                cudnnSoftmaxMode_t mode,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );


cudnnStatus_t cudnnSoftmaxBackward(
                                cudnnHandle_t handle,
                                cudnnSoftmaxAlgorithm_t algo,
                                cudnnSoftmaxMode_t mode,
                                const void *alpha,
                                const cudnnTensorDescriptor_t yDesc,
                                const void *y,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const void *beta,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx );




typedef enum
{
    CUDNN_POOLING_MAX = 0,
    CUDNN_POOLING_AVERAGE_COUNT_INCLUDE_PADDING = 1,
    CUDNN_POOLING_AVERAGE_COUNT_EXCLUDE_PADDING = 2,
    CUDNN_POOLING_MAX_DETERMINISTIC = 3
} cudnnPoolingMode_t;


cudnnStatus_t cudnnCreatePoolingDescriptor(
                                cudnnPoolingDescriptor_t *poolingDesc );

cudnnStatus_t cudnnSetPooling2dDescriptor(
                                cudnnPoolingDescriptor_t poolingDesc,
                                cudnnPoolingMode_t mode,
                                cudnnNanPropagation_t maxpoolingNanOpt,
                                int windowHeight,
                                int windowWidth,
                                int verticalPadding,
                                int horizontalPadding,
                                int verticalStride,
                                int horizontalStride );

cudnnStatus_t cudnnGetPooling2dDescriptor(
                                const cudnnPoolingDescriptor_t poolingDesc,
                                cudnnPoolingMode_t *mode,
                                cudnnNanPropagation_t *maxpoolingNanOpt,
                                int *windowHeight,
                                int *windowWidth,
                                int *verticalPadding,
                                int *horizontalPadding,
                                int *verticalStride,
                                int *horizontalStride );

cudnnStatus_t cudnnSetPoolingNdDescriptor(
                                cudnnPoolingDescriptor_t poolingDesc,
                                const cudnnPoolingMode_t mode,
                                const cudnnNanPropagation_t maxpoolingNanOpt,
                                int nbDims,
                                const int windowDimA[],
                                const int paddingA[],
                                const int strideA[] );

cudnnStatus_t cudnnGetPoolingNdDescriptor(
                                const cudnnPoolingDescriptor_t poolingDesc,
                                int nbDimsRequested,
                                cudnnPoolingMode_t *mode,
                                cudnnNanPropagation_t *maxpoolingNanOpt,
                                int *nbDims,
                                int windowDimA[],
                                int paddingA[],
                                int strideA[] );

cudnnStatus_t cudnnGetPoolingNdForwardOutputDim(
                                const cudnnPoolingDescriptor_t poolingDesc,
                                const cudnnTensorDescriptor_t inputTensorDesc,
                                int nbDims,
                                int outputTensorDimA[] );

cudnnStatus_t cudnnGetPooling2dForwardOutputDim(
                                const cudnnPoolingDescriptor_t poolingDesc,
                                const cudnnTensorDescriptor_t inputTensorDesc,
                                int *n,
                                int *c,
                                int *h,
                                int *w );



cudnnStatus_t cudnnDestroyPoolingDescriptor(
                                cudnnPoolingDescriptor_t poolingDesc );




cudnnStatus_t cudnnPoolingForward(
                                cudnnHandle_t handle,
                                const cudnnPoolingDescriptor_t poolingDesc,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );


cudnnStatus_t cudnnPoolingBackward(
                                cudnnHandle_t handle,
                                const cudnnPoolingDescriptor_t poolingDesc,
                                const void *alpha,
                                const cudnnTensorDescriptor_t yDesc,
                                const void *y,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx );




typedef enum
{
    CUDNN_ACTIVATION_SIGMOID = 0,
    CUDNN_ACTIVATION_RELU = 1,
    CUDNN_ACTIVATION_TANH = 2,
    CUDNN_ACTIVATION_CLIPPED_RELU = 3,
    CUDNN_ACTIVATION_ELU = 4
} cudnnActivationMode_t;


cudnnStatus_t cudnnCreateActivationDescriptor(
                                cudnnActivationDescriptor_t *activationDesc);

cudnnStatus_t cudnnSetActivationDescriptor(
                                cudnnActivationDescriptor_t activationDesc,
                                cudnnActivationMode_t mode,
                                cudnnNanPropagation_t reluNanOpt,
                                double coef );

cudnnStatus_t cudnnGetActivationDescriptor(
                                const cudnnActivationDescriptor_t activationDesc,
                                cudnnActivationMode_t *mode,
                                cudnnNanPropagation_t *reluNanOpt,
                                double* coef );

cudnnStatus_t cudnnDestroyActivationDescriptor(
                                cudnnActivationDescriptor_t activationDesc);


cudnnStatus_t cudnnActivationForward(
                                cudnnHandle_t handle,
                                cudnnActivationDescriptor_t activationDesc,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );


cudnnStatus_t cudnnActivationBackward(
                                cudnnHandle_t handle,
                                cudnnActivationDescriptor_t activationDesc,
                                const void *alpha,
                                const cudnnTensorDescriptor_t yDesc,
                                const void *y,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx );





cudnnStatus_t cudnnCreateLRNDescriptor(
                                cudnnLRNDescriptor_t *normDesc );







typedef enum
{
    CUDNN_LRN_CROSS_CHANNEL_DIM1 = 0,
} cudnnLRNMode_t;






cudnnStatus_t cudnnSetLRNDescriptor(
                                cudnnLRNDescriptor_t normDesc,
                                unsigned lrnN,
                                double lrnAlpha,
                                double lrnBeta,
                                double lrnK );




cudnnStatus_t cudnnGetLRNDescriptor(
                                cudnnLRNDescriptor_t normDesc,
                                unsigned* lrnN,
                                double* lrnAlpha,
                                double* lrnBeta,
                                double* lrnK );


cudnnStatus_t cudnnDestroyLRNDescriptor( cudnnLRNDescriptor_t lrnDesc );




cudnnStatus_t cudnnLRNCrossChannelForward(
                                cudnnHandle_t handle,
                                cudnnLRNDescriptor_t normDesc,
                                cudnnLRNMode_t lrnMode,
                                const void* alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );


cudnnStatus_t cudnnLRNCrossChannelBackward(
                                cudnnHandle_t handle,
                                cudnnLRNDescriptor_t normDesc,
                                cudnnLRNMode_t lrnMode,
                                const void* alpha,
                                const cudnnTensorDescriptor_t yDesc,
                                const void *y,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *beta,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx);

typedef enum
{
    CUDNN_DIVNORM_PRECOMPUTED_MEANS = 0,
} cudnnDivNormMode_t;


cudnnStatus_t cudnnDivisiveNormalizationForward(
                                cudnnHandle_t handle,
                                cudnnLRNDescriptor_t normDesc,
                                cudnnDivNormMode_t mode,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *means,
                                void *temp,
                                void *temp2,
                                const void *beta,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y );

cudnnStatus_t cudnnDivisiveNormalizationBackward(
                                cudnnHandle_t handle,
                                cudnnLRNDescriptor_t normDesc,
                                cudnnDivNormMode_t mode,
                                const void *alpha,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const void *means,
                                const void *dy,
                                void *temp,
                                void *temp2,
                                const void *beta,
                                const cudnnTensorDescriptor_t dXdMeansDesc,
                                void *dx,
                                void *dMeans );

typedef enum
{

    CUDNN_BATCHNORM_PER_ACTIVATION = 0,


    CUDNN_BATCHNORM_SPATIAL = 1,





    CUDNN_BATCHNORM_SPATIAL_PERSISTENT = 2,
} cudnnBatchNormMode_t;
# 1307 "/usr/include/cudnn.h" 3 4
cudnnStatus_t cudnnDeriveBNTensorDescriptor(
                                cudnnTensorDescriptor_t derivedBnDesc,
                                const cudnnTensorDescriptor_t xDesc,
                                cudnnBatchNormMode_t mode );


cudnnStatus_t cudnnBatchNormalizationForwardTraining(
                                cudnnHandle_t handle,
                                cudnnBatchNormMode_t mode,

                                const void *alpha,
                                const void *beta,

                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y,
# 1333 "/usr/include/cudnn.h" 3 4
                                const cudnnTensorDescriptor_t bnScaleBiasMeanVarDesc,


                                const void *bnScale,
                                const void *bnBias,
# 1346 "/usr/include/cudnn.h" 3 4
                                double exponentialAverageFactor,



                                void *resultRunningMean,


                                void *resultRunningVariance,


                                double epsilon,



                                void *resultSaveMean,
                                void *resultSaveInvVariance );
# 1370 "/usr/include/cudnn.h" 3 4
cudnnStatus_t cudnnBatchNormalizationForwardInference(
                                cudnnHandle_t handle,
                                cudnnBatchNormMode_t mode,
                                const void *alpha,
                                const void *beta,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnTensorDescriptor_t yDesc,
                                void *y,
                                const cudnnTensorDescriptor_t bnScaleBiasMeanVarDesc,
                                const void *bnScale,
                                const void *bnBias,
                                const void *estimatedMean,
                                const void *estimatedVariance,
                                double epsilon );



cudnnStatus_t cudnnBatchNormalizationBackward(
                                cudnnHandle_t handle,
                                cudnnBatchNormMode_t mode,
                                const void *alphaDataDiff,
                                const void *betaDataDiff,
                                const void *alphaParamDiff,
                                const void *betaParamDiff,
                                const cudnnTensorDescriptor_t xDesc,
                                const void *x,
                                const cudnnTensorDescriptor_t dyDesc,
                                const void *dy,
                                const cudnnTensorDescriptor_t dxDesc,
                                void *dx,

                                const cudnnTensorDescriptor_t dBnScaleBiasDesc,
                                const void *bnScale,

                                void *dBnScaleResult,
                                void *dBnBiasResult,

                                double epsilon,



                                const void *savedMean,
                                const void *savedInvVariance );



typedef enum {
    CUDNN_SAMPLER_BILINEAR=0,
} cudnnSamplerType_t;

cudnnStatus_t cudnnCreateSpatialTransformerDescriptor(
                               cudnnSpatialTransformerDescriptor_t *stDesc);

cudnnStatus_t cudnnSetSpatialTransformerNdDescriptor(
                                cudnnSpatialTransformerDescriptor_t stDesc,
                                cudnnSamplerType_t samplerType,
                                cudnnDataType_t dataType,
                                const int nbDims,
                                const int dimA[]);

cudnnStatus_t cudnnDestroySpatialTransformerDescriptor(
                                 cudnnSpatialTransformerDescriptor_t stDesc);

cudnnStatus_t cudnnSpatialTfGridGeneratorForward(
                                 cudnnHandle_t handle,
                                 const cudnnSpatialTransformerDescriptor_t stDesc,
                                 const void *theta,
                                 void *grid);

cudnnStatus_t cudnnSpatialTfGridGeneratorBackward(
                                 cudnnHandle_t handle,
                                 const cudnnSpatialTransformerDescriptor_t stDesc,
                                 const void *dgrid,
                                 void *dtheta);

cudnnStatus_t cudnnSpatialTfSamplerForward(
                                 cudnnHandle_t handle,
                                 cudnnSpatialTransformerDescriptor_t stDesc,
                                 const void *alpha,
                                 const cudnnTensorDescriptor_t xDesc,
                                 const void *x,
                                 const void *grid,
                                 const void *beta,
                                 cudnnTensorDescriptor_t yDesc,
                                 void *y);

cudnnStatus_t cudnnSpatialTfSamplerBackward(
                                 cudnnHandle_t handle,
                                 cudnnSpatialTransformerDescriptor_t stDesc,
                                 const void *alpha,
                                 const cudnnTensorDescriptor_t xDesc,
                                 const void *x,
                                 const void *beta,
                                 const cudnnTensorDescriptor_t dxDesc,
                                 void *dx,
                                 const void *alphaDgrid,
                                 const cudnnTensorDescriptor_t dyDesc,
                                 const void *dy,
                                 const void *grid,
                                 const void *betaDgrid,
                                 void *dgrid);

typedef struct cudnnDropoutStruct * cudnnDropoutDescriptor_t;

cudnnStatus_t cudnnCreateDropoutDescriptor(cudnnDropoutDescriptor_t * dropoutDesc);

cudnnStatus_t cudnnDestroyDropoutDescriptor(cudnnDropoutDescriptor_t dropoutDesc);


cudnnStatus_t cudnnDropoutGetStatesSize(cudnnHandle_t handle, size_t * sizeInBytes);


cudnnStatus_t cudnnDropoutGetReserveSpaceSize(cudnnTensorDescriptor_t xdesc, size_t * sizeInBytes);

cudnnStatus_t cudnnSetDropoutDescriptor(cudnnDropoutDescriptor_t dropoutDesc,
                                                    cudnnHandle_t handle,
                                                    float dropout,
                                                    void * states,
                                                    size_t stateSizeInBytes,
                                                    unsigned long long seed);


cudnnStatus_t cudnnRestoreDropoutDescriptor(cudnnDropoutDescriptor_t dropoutDesc,
                                                        cudnnHandle_t handle,
                                                        float dropout,
                                                        void * states,
                                                        size_t stateSizeInBytes,
                                                        unsigned long long seed);

cudnnStatus_t cudnnGetDropoutDescriptor(cudnnDropoutDescriptor_t dropoutDesc,
                                                    cudnnHandle_t handle,
                                                    float * dropout,
                                                    void ** states,
                                                    unsigned long long * seed);

cudnnStatus_t cudnnDropoutForward(cudnnHandle_t handle,
                                              const cudnnDropoutDescriptor_t dropoutDesc,
                                              const cudnnTensorDescriptor_t xdesc,
                                              const void * x,
                                              const cudnnTensorDescriptor_t ydesc,
                                              void * y,
                                              void * reserveSpace,
                                              size_t reserveSpaceSizeInBytes);

cudnnStatus_t cudnnDropoutBackward(cudnnHandle_t handle,
                                               const cudnnDropoutDescriptor_t dropoutDesc,
                                               const cudnnTensorDescriptor_t dydesc,
                                               const void * dy,
                                               const cudnnTensorDescriptor_t dxdesc,
                                               void * dx,
                                               void * reserveSpace,
                                               size_t reserveSpaceSizeInBytes);


typedef enum
  {
    CUDNN_RNN_RELU = 0,
    CUDNN_RNN_TANH = 1,
    CUDNN_LSTM = 2,
    CUDNN_GRU = 3
  } cudnnRNNMode_t;

typedef enum
  {
   CUDNN_UNIDIRECTIONAL = 0,
   CUDNN_BIDIRECTIONAL = 1
  } cudnnDirectionMode_t;

typedef enum
  {
   CUDNN_LINEAR_INPUT = 0,
   CUDNN_SKIP_INPUT = 1
  } cudnnRNNInputMode_t;


typedef enum
  {
    CUDNN_RNN_ALGO_STANDARD = 0,
    CUDNN_RNN_ALGO_PERSIST_STATIC = 1,
    CUDNN_RNN_ALGO_PERSIST_DYNAMIC = 2
  } cudnnRNNAlgo_t;

struct cudnnRNNStruct;
typedef struct cudnnRNNStruct* cudnnRNNDescriptor_t;

cudnnStatus_t cudnnCreateRNNDescriptor(cudnnRNNDescriptor_t * rnnDesc);
cudnnStatus_t cudnnDestroyRNNDescriptor(cudnnRNNDescriptor_t rnnDesc);

struct cudnnPersistentRNNPlan;
typedef struct cudnnPersistentRNNPlan *cudnnPersistentRNNPlan_t;



cudnnStatus_t cudnnCreatePersistentRNNPlan(cudnnRNNDescriptor_t rnnDesc,
                                                       const int minibatch,
                                                       const cudnnDataType_t dataType,
                                                       cudnnPersistentRNNPlan_t * plan);


cudnnStatus_t cudnnSetPersistentRNNPlan(cudnnRNNDescriptor_t rnnDesc,
                                                    cudnnPersistentRNNPlan_t plan);

cudnnStatus_t cudnnDestroyPersistentRNNPlan(cudnnPersistentRNNPlan_t plan);

cudnnStatus_t cudnnSetRNNDescriptor(cudnnHandle_t handle,
                                                   cudnnRNNDescriptor_t rnnDesc,
                                                   const int hiddenSize,
                                                   const int numLayers,
                                                   cudnnDropoutDescriptor_t dropoutDesc,
                                                   cudnnRNNInputMode_t inputMode,
                                                   cudnnDirectionMode_t direction,
                                                   cudnnRNNMode_t mode,
                                                   cudnnRNNAlgo_t algo,
                                                   cudnnDataType_t dataType);

cudnnStatus_t cudnnGetRNNDescriptor(cudnnHandle_t cudnnHandle,
                                                cudnnRNNDescriptor_t rnnDesc,
                                                int * hiddenSize,
                                                int * numLayers,
                                                cudnnDropoutDescriptor_t * dropoutDesc,
                                                cudnnRNNInputMode_t * inputMode,
                                                cudnnDirectionMode_t * direction,
                                                cudnnRNNMode_t * mode,
                                                cudnnRNNAlgo_t * algo,
                                                cudnnDataType_t * dataType);

cudnnStatus_t cudnnSetRNNMatrixMathType (cudnnRNNDescriptor_t desc, cudnnMathType_t math);



cudnnStatus_t cudnnGetRNNWorkspaceSize( cudnnHandle_t handle,
                                                    const cudnnRNNDescriptor_t rnnDesc,
                                                    const int seqLength,
                                                    const cudnnTensorDescriptor_t *xDesc,
                                                    size_t *sizeInBytes);

cudnnStatus_t cudnnGetRNNTrainingReserveSize( cudnnHandle_t handle,
                                                          const cudnnRNNDescriptor_t rnnDesc,
                                                          const int seqLength,
                                                          const cudnnTensorDescriptor_t *xDesc,
                                                          size_t *sizeInBytes);


cudnnStatus_t cudnnGetRNNParamsSize( cudnnHandle_t handle,
                                                 const cudnnRNNDescriptor_t rnnDesc,
                                                 const cudnnTensorDescriptor_t xDesc,
                                                 size_t *sizeInBytes,
                                                 cudnnDataType_t dataType);

cudnnStatus_t cudnnGetRNNLinLayerMatrixParams( cudnnHandle_t handle,
                                                           const cudnnRNNDescriptor_t rnnDesc,
                                                           const int layer,
                                                           const cudnnTensorDescriptor_t xDesc,
                                                           const cudnnFilterDescriptor_t wDesc,
                                                           const void * w,
                                                           const int linLayerID,
                                                           cudnnFilterDescriptor_t linLayerMatDesc,
                                                           void ** linLayerMat);

cudnnStatus_t cudnnGetRNNLinLayerBiasParams( cudnnHandle_t handle,
                                                         const cudnnRNNDescriptor_t rnnDesc,
                                                         const int layer,
                                                         const cudnnTensorDescriptor_t xDesc,
                                                         const cudnnFilterDescriptor_t wDesc,
                                                         const void * w,
                                                         const int linLayerID,
                                                         cudnnFilterDescriptor_t linLayerBiasDesc,
                                                         void ** linLayerBias);

cudnnStatus_t cudnnRNNForwardInference( cudnnHandle_t handle,
                                                    const cudnnRNNDescriptor_t rnnDesc,
                                                    const int seqLength,
                                                    const cudnnTensorDescriptor_t * xDesc,
                                                    const void * x,
                                                    const cudnnTensorDescriptor_t hxDesc,
                                                    const void * hx,
                                                    const cudnnTensorDescriptor_t cxDesc,
                                                    const void * cx,
                                                    const cudnnFilterDescriptor_t wDesc,
                                                    const void * w,
                                                    const cudnnTensorDescriptor_t *yDesc,
                                                    void * y,
                                                    const cudnnTensorDescriptor_t hyDesc,
                                                    void * hy,
                                                    const cudnnTensorDescriptor_t cyDesc,
                                                    void * cy,
                                                    void * workspace,
                                                    size_t workSpaceSizeInBytes);

cudnnStatus_t cudnnRNNForwardTraining( cudnnHandle_t handle,
                                                   const cudnnRNNDescriptor_t rnnDesc,
                                                   const int seqLength,
                                                   const cudnnTensorDescriptor_t *xDesc,
                                                   const void * x,
                                                   const cudnnTensorDescriptor_t hxDesc,
                                                   const void * hx,
                                                   const cudnnTensorDescriptor_t cxDesc,
                                                   const void * cx,
                                                   const cudnnFilterDescriptor_t wDesc,
                                                   const void * w,
                                                   const cudnnTensorDescriptor_t *yDesc,
                                                   void * y,
                                                   const cudnnTensorDescriptor_t hyDesc,
                                                   void * hy,
                                                   const cudnnTensorDescriptor_t cyDesc,
                                                   void * cy,
                                                   void * workspace,
                                                   size_t workSpaceSizeInBytes,
                                                   void * reserveSpace,
                                                   size_t reserveSpaceSizeInBytes);

cudnnStatus_t cudnnRNNBackwardData( cudnnHandle_t handle,
                                                const cudnnRNNDescriptor_t rnnDesc,
                                                const int seqLength,
                                                const cudnnTensorDescriptor_t * yDesc,
                                                const void * y,
                                                const cudnnTensorDescriptor_t * dyDesc,
                                                const void * dy,
                                                const cudnnTensorDescriptor_t dhyDesc,
                                                const void * dhy,
                                                const cudnnTensorDescriptor_t dcyDesc,
                                                const void * dcy,
                                                const cudnnFilterDescriptor_t wDesc,
                                                const void * w,
                                                const cudnnTensorDescriptor_t hxDesc,
                                                const void * hx,
                                                const cudnnTensorDescriptor_t cxDesc,
                                                const void * cx,
                                                const cudnnTensorDescriptor_t * dxDesc,
                                                void * dx,
                                                const cudnnTensorDescriptor_t dhxDesc,
                                                void * dhx,
                                                const cudnnTensorDescriptor_t dcxDesc,
                                                void * dcx,
                                                void * workspace,
                                                size_t workSpaceSizeInBytes,
                                                void * reserveSpace,
                                                size_t reserveSpaceSizeInBytes );


cudnnStatus_t cudnnRNNBackwardWeights( cudnnHandle_t handle,
                                                   const cudnnRNNDescriptor_t rnnDesc,
                                                   const int seqLength,
                                                   const cudnnTensorDescriptor_t * xDesc,
                                                   const void * x,
                                                   const cudnnTensorDescriptor_t hxDesc,
                                                   const void * hx,
                                                   const cudnnTensorDescriptor_t * yDesc,
                                                   const void * y,
                                                   const void * workspace,
                                                   size_t workSpaceSizeInBytes,
                                                   const cudnnFilterDescriptor_t dwDesc,
                                                   void * dw,
                                                   const void * reserveSpace,
                                                   size_t reserveSpaceSizeInBytes );

typedef enum
{
    CUDNN_CTC_LOSS_ALGO_DETERMINISTIC = 0,
    CUDNN_CTC_LOSS_ALGO_NON_DETERMINISTIC = 1
}cudnnCTCLossAlgo_t;




cudnnStatus_t cudnnCreateCTCLossDescriptor( cudnnCTCLossDescriptor_t* ctcLossDesc );

cudnnStatus_t cudnnSetCTCLossDescriptor(
                                cudnnCTCLossDescriptor_t ctcLossDesc,
                                cudnnDataType_t compType );

cudnnStatus_t cudnnGetCTCLossDescriptor(
                                cudnnCTCLossDescriptor_t ctcLossDesc,
                                cudnnDataType_t* compType );

cudnnStatus_t cudnnDestroyCTCLossDescriptor( cudnnCTCLossDescriptor_t ctcLossDesc );


cudnnStatus_t cudnnCTCLoss( cudnnHandle_t handle,
                                        const cudnnTensorDescriptor_t probsDesc,
                                        const void * probs,
                                        const int * labels,
                                        const int * labelLengths,
                                        const int * inputLengths,
                                        void * costs,
                                        const cudnnTensorDescriptor_t gradientsDesc,
                                        const void * gradients,
                                        cudnnCTCLossAlgo_t algo,
                                        cudnnCTCLossDescriptor_t ctcLossDesc,
                                        void * workspace,
                                        size_t workSpaceSizeInBytes);


cudnnStatus_t cudnnGetCTCLossWorkspaceSize(
                                cudnnHandle_t handle,
                                const cudnnTensorDescriptor_t probsDesc,
                                const cudnnTensorDescriptor_t gradientsDesc,
                                const int * labels,
                                const int * labelLengths,
                                const int * inputLengths,
                                cudnnCTCLossAlgo_t algo,
                                cudnnCTCLossDescriptor_t ctcLossDesc,
                                size_t *sizeInBytes );







cudnnStatus_t cudnnSetRNNDescriptor_v6(cudnnHandle_t handle,
                                                   cudnnRNNDescriptor_t rnnDesc,
                                                   const int hiddenSize,
                                                   const int numLayers,
                                                   cudnnDropoutDescriptor_t dropoutDesc,
                                                   cudnnRNNInputMode_t inputMode,
                                                   cudnnDirectionMode_t direction,
                                                   cudnnRNNMode_t mode,
                                                   cudnnRNNAlgo_t algo,
                                                   cudnnDataType_t dataType);

cudnnStatus_t cudnnSetRNNDescriptor_v5(cudnnRNNDescriptor_t rnnDesc,
                                                int hiddenSize,
                                                int numLayers,
                                                cudnnDropoutDescriptor_t dropoutDesc,
                                                cudnnRNNInputMode_t inputMode,
                                                cudnnDirectionMode_t direction,
                                                cudnnRNNMode_t mode,
                                                cudnnDataType_t dataType);

}
# 21 "include/darknet.h" 2
# 36 "include/darknet.h"

# 36 "include/darknet.h"
typedef struct{
    int classes;
    char **names;
} metadata;
metadata get_metadata(char *file);

typedef struct{
    int *leaf;
    int n;
    int *parent;
    int *child;
    int *group;
    char **name;

    int groups;
    int *group_size;
    int *group_offset;
} tree;
tree *read_tree(char *filename);

typedef enum{
    LOGISTIC, RELU, RELIE, LINEAR, RAMP, TANH, PLSE, LEAKY, ELU, LOGGY, STAIR, HARDTAN, LHTAN
} ACTIVATION;

typedef enum{
    MULT, ADD, SUB, DIV
} BINARY_ACTIVATION;

typedef enum {
    CONVOLUTIONAL,
    DECONVOLUTIONAL,
    CONNECTED,
    MAXPOOL,
    SOFTMAX,
    DETECTION,
    DROPOUT,
    CROP,
    ROUTE,
    COST,
    NORMALIZATION,
    AVGPOOL,
    LOCAL,
    SHORTCUT,
    ACTIVE,
    RNN,
    GRU,
    LSTM,
    CRNN,
    BATCHNORM,
    NETWORK,
    XNOR,
    REGION,
    YOLO,
    REORG,
    UPSAMPLE,
    LOGXENT,
    L2NORM,
    BLANK,
    DEPTHWISE_CONVOLUTIONAL
} LAYER_TYPE;

typedef enum{
    SSE, MASKED, L1, SEG, SMOOTH,WGAN
} COST_TYPE;

typedef struct{
    int batch;
    float learning_rate;
    float momentum;
    float decay;
    int adam;
    float B1;
    float B2;
    float eps;
    int t;
} update_args;

struct network;
typedef struct network network;

struct layer;
typedef struct layer layer;

struct layer{
    LAYER_TYPE type;
    ACTIVATION activation;
    COST_TYPE cost_type;
    void (*forward) (struct layer, struct network);
    void (*backward) (struct layer, struct network);
    void (*update) (struct layer, update_args);
    void (*forward_gpu) (struct layer, struct network);
    void (*backward_gpu) (struct layer, struct network);
    void (*update_gpu) (struct layer, update_args);
    int batch_normalize;
    int shortcut;
    int batch;
    int forced;
    int flipped;
    int inputs;
    int outputs;
    int nweights;
    int nbiases;
    int extra;
    int truths;
    int h,w,c;
    int out_h, out_w, out_c;
    int n;
    int max_boxes;
    int groups;
    int size;
    int side;
    int stride;
    int reverse;
    int flatten;
    int spatial;
    int pad;
    int sqrt;
    int flip;
    int index;
    int binary;
    int xnor;
    int steps;
    int hidden;
    int truth;
    float smooth;
    float dot;
    float angle;
    float jitter;
    float saturation;
    float exposure;
    float shift;
    float ratio;
    float learning_rate_scale;
    float clip;
    int softmax;
    int classes;
    int coords;
    int background;
    int rescore;
    int objectness;
    int joint;
    int noadjust;
    int reorg;
    int log;
    int tanh;
    int *mask;
    int total;

    float alpha;
    float beta;
    float kappa;

    float coord_scale;
    float object_scale;
    float noobject_scale;
    float mask_scale;
    float class_scale;
    int bias_match;
    int random;
    float ignore_thresh;
    float truth_thresh;
    float thresh;
    float focus;
    int classfix;
    int absolute;

    int onlyforward;
    int stopbackward;
    int dontload;
    int dontsave;
    int dontloadscales;

    float temperature;
    float probability;
    float scale;

    char * cweights;
    int * indexes;
    int * input_layers;
    int * input_sizes;
    int * map;
    float * rand;
    float * cost;
    float * state;
    float * prev_state;
    float * forgot_state;
    float * forgot_delta;
    float * state_delta;
    float * combine_cpu;
    float * combine_delta_cpu;

    float * concat;
    float * concat_delta;

    float * binary_weights;

    float * biases;
    float * bias_updates;

    float * scales;
    float * scale_updates;

    float * weights;
    float * weight_updates;

    float * delta;
    float * output;
    float * loss;
    float * squared;
    float * norms;

    float * spatial_mean;
    float * mean;
    float * variance;

    float * mean_delta;
    float * variance_delta;

    float * rolling_mean;
    float * rolling_variance;

    float * x;
    float * x_norm;

    float * m;
    float * v;

    float * bias_m;
    float * bias_v;
    float * scale_m;
    float * scale_v;


    float *z_cpu;
    float *r_cpu;
    float *h_cpu;
    float * prev_state_cpu;

    float *temp_cpu;
    float *temp2_cpu;
    float *temp3_cpu;

    float *dh_cpu;
    float *hh_cpu;
    float *prev_cell_cpu;
    float *cell_cpu;
    float *f_cpu;
    float *i_cpu;
    float *g_cpu;
    float *o_cpu;
    float *c_cpu;
    float *dc_cpu;

    float * binary_input;

    struct layer *input_layer;
    struct layer *self_layer;
    struct layer *output_layer;

    struct layer *reset_layer;
    struct layer *update_layer;
    struct layer *state_layer;

    struct layer *input_gate_layer;
    struct layer *state_gate_layer;
    struct layer *input_save_layer;
    struct layer *state_save_layer;
    struct layer *input_state_layer;
    struct layer *state_state_layer;

    struct layer *input_z_layer;
    struct layer *state_z_layer;

    struct layer *input_r_layer;
    struct layer *state_r_layer;

    struct layer *input_h_layer;
    struct layer *state_h_layer;

    struct layer *wz;
    struct layer *uz;
    struct layer *wr;
    struct layer *ur;
    struct layer *wh;
    struct layer *uh;
    struct layer *uo;
    struct layer *wo;
    struct layer *uf;
    struct layer *wf;
    struct layer *ui;
    struct layer *wi;
    struct layer *ug;
    struct layer *wg;

    tree *softmax_tree;

    size_t workspace_size;


    int *indexes_gpu;

    float *z_gpu;
    float *r_gpu;
    float *h_gpu;

    float *temp_gpu;
    float *temp2_gpu;
    float *temp3_gpu;

    float *dh_gpu;
    float *hh_gpu;
    float *prev_cell_gpu;
    float *cell_gpu;
    float *f_gpu;
    float *i_gpu;
    float *g_gpu;
    float *o_gpu;
    float *c_gpu;
    float *dc_gpu;

    float *m_gpu;
    float *v_gpu;
    float *bias_m_gpu;
    float *scale_m_gpu;
    float *bias_v_gpu;
    float *scale_v_gpu;

    float * combine_gpu;
    float * combine_delta_gpu;

    float * prev_state_gpu;
    float * forgot_state_gpu;
    float * forgot_delta_gpu;
    float * state_gpu;
    float * state_delta_gpu;
    float * gate_gpu;
    float * gate_delta_gpu;
    float * save_gpu;
    float * save_delta_gpu;
    float * concat_gpu;
    float * concat_delta_gpu;

    float * binary_input_gpu;
    float * binary_weights_gpu;

    float * mean_gpu;
    float * variance_gpu;

    float * rolling_mean_gpu;
    float * rolling_variance_gpu;

    float * variance_delta_gpu;
    float * mean_delta_gpu;

    float * x_gpu;
    float * x_norm_gpu;
    float * weights_gpu;
    float * weight_updates_gpu;
    float * weight_change_gpu;

    float * biases_gpu;
    float * bias_updates_gpu;
    float * bias_change_gpu;

    float * scales_gpu;
    float * scale_updates_gpu;
    float * scale_change_gpu;

    float * output_gpu;
    float * loss_gpu;
    float * delta_gpu;
    float * rand_gpu;
    float * squared_gpu;
    float * norms_gpu;

    cudnnTensorDescriptor_t srcTensorDesc, dstTensorDesc;
    cudnnTensorDescriptor_t dsrcTensorDesc, ddstTensorDesc;
    cudnnTensorDescriptor_t normTensorDesc;
    cudnnFilterDescriptor_t weightDesc;
    cudnnFilterDescriptor_t dweightDesc;
    cudnnConvolutionDescriptor_t convDesc;
    cudnnConvolutionFwdAlgo_t fw_algo;
    cudnnConvolutionBwdDataAlgo_t bd_algo;
    cudnnConvolutionBwdFilterAlgo_t bf_algo;


};

void free_layer(layer);

typedef enum {
    CONSTANT, STEP, EXP, POLY, STEPS, SIG, RANDOM
} learning_rate_policy;

typedef struct network{
    int n;
    int batch;
    size_t *seen;
    int *t;
    float epoch;
    int subdivisions;
    layer *layers;
    float *output;
    learning_rate_policy policy;

    float learning_rate;
    float momentum;
    float decay;
    float gamma;
    float scale;
    float power;
    int time_steps;
    int step;
    int max_batches;
    float *scales;
    int *steps;
    int num_steps;
    int burn_in;

    int adam;
    float B1;
    float B2;
    float eps;

    int inputs;
    int outputs;
    int truths;
    int notruth;
    int h, w, c;
    int max_crop;
    int min_crop;
    float max_ratio;
    float min_ratio;
    int center;
    float angle;
    float aspect;
    float exposure;
    float saturation;
    float hue;
    int random;

    int gpu_index;
    tree *hierarchy;

    float *input;
    float *truth;
    float *delta;
    float *workspace;
    int train;
    int index;
    float *cost;
    float clip;


    float *input_gpu;
    float *truth_gpu;
    float *delta_gpu;
    float *output_gpu;


} network;

typedef struct {
    int w;
    int h;
    float scale;
    float rad;
    float dx;
    float dy;
    float aspect;
} augment_args;

typedef struct {
    int w;
    int h;
    int c;
    float *data;
} image;

typedef struct{
    float x, y, w, h;
} box;

typedef struct detection{
    box bbox;
    int classes;
    float *prob;
    float *mask;
    float objectness;
    int sort_class;
} detection;

typedef struct matrix{
    int rows, cols;
    float **vals;
} matrix;


typedef struct{
    int w, h;
    matrix X;
    matrix y;
    int shallow;
    int *num_boxes;
    box **boxes;
} data;

typedef enum {
    CLASSIFICATION_DATA, DETECTION_DATA, CAPTCHA_DATA, REGION_DATA, IMAGE_DATA, COMPARE_DATA, WRITING_DATA, SWAG_DATA, TAG_DATA, OLD_CLASSIFICATION_DATA, STUDY_DATA, DET_DATA, SUPER_DATA, LETTERBOX_DATA, REGRESSION_DATA, SEGMENTATION_DATA, INSTANCE_DATA
} data_type;

typedef struct load_args{
    int threads;
    char **paths;
    char *path;
    int n;
    int m;
    char **labels;
    int h;
    int w;
    int out_w;
    int out_h;
    int nh;
    int nw;
    int num_boxes;
    int min, max, size;
    int classes;
    int background;
    int scale;
    int center;
    int coords;
    float jitter;
    float angle;
    float aspect;
    float saturation;
    float exposure;
    float hue;
    data *d;
    image *im;
    image *resized;
    data_type type;
    tree *hierarchy;
} load_args;

typedef struct{
    int id;
    float x,y,w,h;
    float left, right, top, bottom;
} box_label;


network *load_network(char *cfg, char *weights, int clear);
load_args get_base_args(network *net);

void free_data(data d);

typedef struct node{
    void *val;
    struct node *next;
    struct node *prev;
} node;

typedef struct list{
    int size;
    node *front;
    node *back;
} list;

pthread_t load_data(load_args args);
list *read_data_cfg(char *filename);
list *read_cfg(char *filename);
unsigned char *read_file(char *filename);
data resize_data(data orig, int w, int h);
data *tile_data(data orig, int divs, int size);
data select_data(data *orig, int *inds);

void forward_network(network *net);
void backward_network(network *net);
void update_network(network *net);


float dot_cpu(int N, float *X, int INCX, float *Y, int INCY);
void axpy_cpu(int N, float ALPHA, float *X, int INCX, float *Y, int INCY);
void copy_cpu(int N, float *X, int INCX, float *Y, int INCY);
void scal_cpu(int N, float ALPHA, float *X, int INCX);
void fill_cpu(int N, float ALPHA, float * X, int INCX);
void normalize_cpu(float *x, float *mean, float *variance, int batch, int filters, int spatial);
void softmax(float *input, int n, float temp, int stride, float *output);

int best_3d_shift_r(image a, image b, int min, int max);

void axpy_gpu(int N, float ALPHA, float * X, int INCX, float * Y, int INCY);
void fill_gpu(int N, float ALPHA, float * X, int INCX);
void scal_gpu(int N, float ALPHA, float * X, int INCX);
void copy_gpu(int N, float * X, int INCX, float * Y, int INCY);

void cuda_set_device(int n);
void cuda_free(float *x_gpu);
float *cuda_make_array(float *x, size_t n);
void cuda_pull_array(float *x_gpu, float *x, size_t n);
float cuda_mag_array(float *x_gpu, size_t n);
void cuda_push_array(float *x_gpu, float *x, size_t n);

void forward_network_gpu(network *net);
void backward_network_gpu(network *net);
void update_network_gpu(network *net);

float train_networks(network **nets, int n, data d, int interval);
void sync_nets(network **nets, int n, int interval);
void harmless_update_network_gpu(network *net);

image get_label(image **characters, char *string, int size);
void draw_label(image a, int r, int c, image label, const float *rgb);
void save_image_png(image im, const char *name);
void get_next_batch(data d, int n, int offset, float *X, float *y);
void grayscale_image_3c(image im);
void normalize_image(image p);
void matrix_to_csv(matrix m);
float train_network_sgd(network *net, data d, int n);
void rgbgr_image(image im);
data copy_data(data d);
data concat_data(data d1, data d2);
data load_cifar10_data(char *filename);
float matrix_topk_accuracy(matrix truth, matrix guess, int k);
void matrix_add_matrix(matrix from, matrix to);
void scale_matrix(matrix m, float scale);
matrix csv_to_matrix(char *filename);
float *network_accuracies(network *net, data d, int n);
float train_network_datum(network *net);
image make_random_image(int w, int h, int c);

void denormalize_connected_layer(layer l);
void denormalize_convolutional_layer(layer l);
void statistics_connected_layer(layer l);
void rescale_weights(layer l, float scale, float trans);
void rgbgr_weights(layer l);
image *get_weights(layer l);

void demo(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int frame_skip, char *prefix, int avg, float hier_thresh, int w, int h, int fps, int fullscreen);
void tracking(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int frame_skip, char *prefix, int avg, float hier_thresh, int w, int h, int fps, int fullscreen);




void demo_TS(char *cfgfile, char *weightfile, float thresh, int cam_index, const char *filename, char **names, int classes, int delay, char *prefix, int avg_frames, float hier, int w, int h, int frames, int fullscreen);





void get_detection_detections(layer l, int w, int h, float thresh, detection *dets);

char *option_find_str(list *l, char *key, char *def);
int option_find_int(list *l, char *key, int def);
int option_find_int_quiet(list *l, char *key, int def);

network *parse_network_cfg(char *filename);
void save_weights(network *net, char *filename);
void load_weights(network *net, char *filename);
void save_weights_upto(network *net, char *filename, int cutoff);
void load_weights_upto(network *net, char *filename, int start, int cutoff);

void zero_objectness(layer l);
void get_region_detections(layer l, int w, int h, int netw, int neth, float thresh, int *map, float tree_thresh, int relative, detection *dets);
int get_yolo_detections(layer l, int w, int h, int netw, int neth, float thresh, int *map, int relative, detection *dets);
void free_network(network *net);
void set_batch_network(network *net, int b);
void set_temp_network(network *net, float t);
image load_image(char *filename, int w, int h, int c);
image load_image_color(char *filename, int w, int h);
image make_image(int w, int h, int c);
image resize_image(image im, int w, int h);
void censor_image(image im, int dx, int dy, int w, int h);
image letterbox_image(image im, int w, int h);
image crop_image(image im, int dx, int dy, int w, int h);
image center_crop_image(image im, int w, int h);
image resize_min(image im, int min);
image resize_max(image im, int max);
image threshold_image(image im, float thresh);
image mask_to_rgb(image mask);
int resize_network(network *net, int w, int h);
void free_matrix(matrix m);
void test_resize(char *filename);
void save_image(image p, const char *name);
void show_image(image p, const char *name);
image copy_image(image p);
void draw_box_width(image a, int x1, int y1, int x2, int y2, int w, float r, float g, float b);
float get_current_rate(network *net);
void composite_3d(char *f1, char *f2, char *out, int delta);
data load_data_old(char **paths, int n, int m, char **labels, int k, int w, int h);
size_t get_current_batch(network *net);
void constrain_image(image im);
image get_network_image_layer(network *net, int i);
layer get_network_output_layer(network *net);
void top_predictions(network *net, int n, int *index);
void flip_image(image a);
image float_to_image(int w, int h, int c, float *data);
void ghost_image(image source, image dest, int dx, int dy);
float network_accuracy(network *net, data d);
void random_distort_image(image im, float hue, float saturation, float exposure);
void fill_image(image m, float s);
image grayscale_image(image im);
void rotate_image_cw(image im, int times);
double what_time_is_it_now();
image rotate_image(image m, float rad);
void visualize_network(network *net);
float box_iou(box a, box b);
data load_all_cifar10();
box_label *read_boxes(char *filename, int *n);
box float_to_box(float *f, int stride);
void draw_detections(image im, detection *dets, int num, float thresh, char **names, image **alphabet, int classes);

matrix network_predict_data(network *net, data test);
image **load_alphabet();
image get_network_image(network *net);
float *network_predict(network *net, float *input);

int network_width(network *net);
int network_height(network *net);
float *network_predict_image(network *net, image im);
void network_detect(network *net, image im, float thresh, float hier_thresh, float nms, detection *dets);
detection *get_network_boxes(network *net, int w, int h, float thresh, float hier, int *map, int relative, int *num);
void free_detections(detection *dets, int n);

void reset_network_state(network *net, int b);

char **get_labels(char *filename);
void do_nms_obj(detection *dets, int total, int classes, float thresh);
void do_nms_sort(detection *dets, int total, int classes, float thresh);

matrix make_matrix(int rows, int cols);






void free_image(image m);
float train_network(network *net, data d);
pthread_t load_data_in_thread(load_args args);
void load_data_blocking(load_args args);
list *get_paths(char *filename);
void hierarchy_predictions(float *predictions, int n, tree *hier, int only_leaves, int stride);
void change_leaves(tree *t, char *leaf_list);

int find_int_arg(int argc, char **argv, char *arg, int def);
float find_float_arg(int argc, char **argv, char *arg, float def);
int find_arg(int argc, char* argv[], char *arg);
char *find_char_arg(int argc, char **argv, char *arg, char *def);
char *basecfg(char *cfgfile);
void find_replace(char *str, char *orig, char *rep, char *output);
void free_ptrs(void **ptrs, int n);
char *fgetl(FILE *fp);
void strip(char *s);
float sec(clock_t clocks);
void **list_to_array(list *l);
void top_k(float *a, int n, int k, int *index);
int *read_map(char *filename);
void error(const char *s);
int max_index(float *a, int n);
int max_int_index(int *a, int n);
int sample_array(float *a, int n);
int *random_index_order(int min, int max);
void free_list(list *l);
float mse_array(float *a, int n);
float variance_array(float *a, int n);
float mag_array(float *a, int n);
void scale_array(float *a, int n, float s);
float mean_array(float *a, int n);
float sum_array(float *a, int n);
void normalize_array(float *a, int n);
int *read_intlist(char *s, int *n, int d);
size_t rand_size_t();
float rand_normal();
float rand_uniform(float min, float max);
# 4 "./src/box.h" 2

typedef struct{
    float dx, dy, dw, dh;
} dbox;

float box_rmse(box a, box b);
dbox diou(box a, box b);
box decode_box(box b, box anchor);
box encode_box(box b, box anchor);
# 10 "./src/image.h" 2
# 22 "./src/image.h"
float get_color(int c, int x, int max);
void draw_box(image a, int x1, int y1, int x2, int y2, float r, float g, float b);
void draw_bbox(image a, box bbox, int w, float r, float g, float b);
void write_label(image a, int r, int c, image *characters, char *string, float *rgb);
image image_distance(image a, image b);
void scale_image(image m, float s);
image rotate_crop_image(image im, float rad, float s, int w, int h, float dx, float dy, float aspect);
image random_crop_image(image im, int w, int h);
image random_augment_image(image im, float angle, float aspect, int low, int high, int w, int h);
augment_args random_augment_args(image im, float angle, float aspect, int low, int high, int w, int h);
void letterbox_image_into(image im, int w, int h, image boxed);
image resize_max(image im, int max);
void translate_image(image m, float s);
void embed_image(image source, image dest, int dx, int dy);
void place_image(image im, int w, int h, int dx, int dy, image canvas);
void saturate_image(image im, float sat);
void exposure_image(image im, float sat);
void distort_image(image im, float hue, float sat, float val);
void saturate_exposure_image(image im, float sat, float exposure);
void rgb_to_hsv(image im);
void hsv_to_rgb(image im);
void yuv_to_rgb(image im);
void rgb_to_yuv(image im);


image collapse_image_layers(image source, int border);
image collapse_images_horz(image *ims, int n);
image collapse_images_vert(image *ims, int n);

void show_image_normalized(image im, const char *name);
void show_images(image *ims, int n, char *window);
void show_image_layers(image p, char *name);
void show_image_collapsed(image p, char *name);

void print_image(image m);

image make_empty_image(int w, int h, int c);
void copy_image_into(image src, image dest);

image get_image_layer(image m, int l);
# 5 "./src/maxpool_layer.h" 2
# 1 "./src/cuda.h" 1







void check_error(cudaError_t status);
cublasHandle_t blas_handle();
int *cuda_make_int_array(int *x, size_t n);
void cuda_random(float *x_gpu, size_t n);
float cuda_compare(float *x_gpu, float *x, size_t n, char *s);
dim3 cuda_gridsize(size_t n);


cudnnHandle_t cudnn_handle();
# 6 "./src/maxpool_layer.h" 2
# 1 "./src/layer.h" 1
# 7 "./src/maxpool_layer.h" 2
# 1 "./src/network.h" 1






# 1 "./src/layer.h" 1
# 8 "./src/network.h" 2
# 1 "./src/data.h" 1





# 1 "./src/matrix.h" 1




matrix copy_matrix(matrix m);
void print_matrix(matrix m);

matrix hold_out_matrix(matrix *m, int n);
matrix resize_matrix(matrix m, int size);

float *pop_column(matrix *m, int c);
# 7 "./src/data.h" 2
# 1 "./src/list.h" 1




list *make_list();
int list_find(list *l, void *val);

void list_insert(list *, void *);


void free_list_contents(list *l);
# 8 "./src/data.h" 2

# 1 "./src/tree.h" 1




int hierarchy_top_prediction(float *predictions, tree *hier, float thresh, int stride);
float get_hierarchy_probability(float *x, tree *hier, int c, int stride);
# 10 "./src/data.h" 2

static inline float distance_from_edge(int x, int max)
{
    int dx = (max/2) - x;
    if (dx < 0) dx = -dx;
    dx = (max/2) + 1 - dx;
    dx *= 2;
    float dist = (float)dx/max;
    if (dist > 1) dist = 1;
    return dist;
}
void load_data_blocking(load_args args);


void print_letters(float *pred, int n);
data load_data_captcha(char **paths, int n, int m, int k, int w, int h);
data load_data_captcha_encode(char **paths, int n, int m, int w, int h);
data load_data_detection(int n, char **paths, int m, int w, int h, int boxes, int classes, float jitter, float hue, float saturation, float exposure);
data load_data_tag(char **paths, int n, int m, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure);
matrix load_image_augment_paths(char **paths, int n, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure, int center);
data load_data_super(char **paths, int n, int m, int w, int h, int scale);
data load_data_augment(char **paths, int n, int m, char **labels, int k, tree *hierarchy, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure, int center);
data load_data_regression(char **paths, int n, int m, int classes, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure);
data load_go(char *filename);


data load_data_writing(char **paths, int n, int m, int w, int h, int out_w, int out_h);

void get_random_batch(data d, int n, float *X, float *y);
data get_data_part(data d, int part, int total);
data get_random_data(data d, int num);
data load_categorical_data_csv(char *filename, int target, int k);
void normalize_data_rows(data d);
void scale_data_rows(data d, float s);
void translate_data_rows(data d, float s);
void randomize_data(data d);
data *split_data(data d, int part, int total);
data concat_datas(data *d, int n);
void fill_truth(char *path, char **labels, int k, float *truth);
# 9 "./src/network.h" 2




void pull_network_output(network *net);


void compare_networks(network *n1, network *n2, data d);
char *get_layer_string(LAYER_TYPE a);

network *make_network(int n);


float network_accuracy_multi(network *net, data d, int n);
int get_predicted_class_network(network *net);
void print_network(network *net);
int resize_network(network *net, int w, int h);
void calc_network_cost(network *net);
# 8 "./src/maxpool_layer.h" 2

typedef layer maxpool_layer;

image get_maxpool_image(maxpool_layer l);
maxpool_layer make_maxpool_layer(int batch, int h, int w, int c, int size, int stride, int padding);
void resize_maxpool_layer(maxpool_layer *l, int w, int h);
void forward_maxpool_layer(const maxpool_layer l, network net);
void backward_maxpool_layer(const maxpool_layer l, network net);


void forward_maxpool_layer_gpu(maxpool_layer l, network net);
void backward_maxpool_layer_gpu(maxpool_layer l, network net);
# 7 "./src/maxpool_layer_kernels.cu" 2

}

__attribute__((global)) void forward_maxpool_layer_kernel(int n, int in_h, int in_w, int in_c, int stride, int size, int pad, float *input, float *output, int *indexes)
{
    int h = (in_h + 2*pad)/stride;
    int w = (in_w + 2*pad)/stride;
    int c = in_c;

    int id = (blockIdx.x + blockIdx.y*gridDim.x) * blockDim.x + threadIdx.x;
    if(id >= n) return;

    int j = id % w;
    id /= w;
    int i = id % h;
    id /= h;
    int k = id % c;
    id /= c;
    int b = id;

    int w_offset = -pad;
    int h_offset = -pad;

    int out_index = j + w*(i + h*(k + c*b));
    float max = -
# 31 "./src/maxpool_layer_kernels.cu" 3 4
                (__builtin_inff())
# 31 "./src/maxpool_layer_kernels.cu"
                        ;
    int max_i = -1;
    int l, m;
    for(l = 0; l < size; ++l){
        for(m = 0; m < size; ++m){
            int cur_h = h_offset + i*stride + l;
            int cur_w = w_offset + j*stride + m;
            int index = cur_w + in_w*(cur_h + in_h*(k + b*in_c));
            int valid = (cur_h >= 0 && cur_h < in_h &&
                    cur_w >= 0 && cur_w < in_w);
            float val = (valid != 0) ? input[index] : -
# 41 "./src/maxpool_layer_kernels.cu" 3 4
                                                      (__builtin_inff())
# 41 "./src/maxpool_layer_kernels.cu"
                                                              ;
            max_i = (val > max) ? index : max_i;
            max = (val > max) ? val : max;
        }
    }
    output[out_index] = max;
    indexes[out_index] = max_i;
}

__attribute__((global)) void backward_maxpool_layer_kernel(int n, int in_h, int in_w, int in_c, int stride, int size, int pad, float *delta, float *prev_delta, int *indexes)
{
    int h = (in_h + 2*pad)/stride;
    int w = (in_w + 2*pad)/stride;
    int c = in_c;
    int area = (size-1)/stride;

    int id = (blockIdx.x + blockIdx.y*gridDim.x) * blockDim.x + threadIdx.x;
    if(id >= n) return;

    int index = id;
    int j = id % in_w;
    id /= in_w;
    int i = id % in_h;
    id /= in_h;
    int k = id % in_c;
    id /= in_c;
    int b = id;

    int w_offset = -pad;
    int h_offset = -pad;

    float d = 0;
    int l, m;
    for(l = -area; l < area+1; ++l){
        for(m = -area; m < area+1; ++m){
            int out_w = (j-w_offset)/stride + m;
            int out_h = (i-h_offset)/stride + l;
            int out_index = out_w + w*(out_h + h*(k + c*b));
            int valid = (out_w >= 0 && out_w < w &&
                     out_h >= 0 && out_h < h);
            d += (valid && indexes[out_index] == index) ? delta[out_index] : 0;
        }
    }
    prev_delta[index] += d;
}

extern "C" void forward_maxpool_layer_gpu(maxpool_layer layer, network net)
{
    int h = layer.out_h;
    int w = layer.out_w;
    int c = layer.c;

    size_t n = h*w*c*layer.batch;

    forward_maxpool_layer_kernel<<<cuda_gridsize(n), 512>>>(n, layer.h, layer.w, layer.c, layer.stride, layer.size, layer.pad, net.input_gpu, layer.output_gpu, layer.indexes_gpu);
    check_error(cudaPeekAtLastError());
}

extern "C" void backward_maxpool_layer_gpu(maxpool_layer layer, network net)
{
    size_t n = layer.h*layer.w*layer.c*layer.batch;

    backward_maxpool_layer_kernel<<<cuda_gridsize(n), 512>>>(n, layer.h, layer.w, layer.c, layer.stride, layer.size, layer.pad, layer.delta_gpu, net.delta_gpu, layer.indexes_gpu);
    check_error(cudaPeekAtLastError());
}