topk_app.cpp1.ii

# 1 "/Users/jowens/Documents/working/gunrock/gunrock/app/topk/topk_app.cu"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 339 "<built-in>" 3
# 1 "<command line>" 1






# 1 "/usr/local/cuda/include/cuda_runtime.h" 1
# 62 "/usr/local/cuda/include/cuda_runtime.h"
# 1 "/usr/local/cuda/include/host_config.h" 1
# 63 "/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
# 223 "/usr/local/cuda/include/host_defines.h"
template <typename T> struct __nv_clang_atomic_t {
  __nv_clang_atomic_t() noexcept;
  __nv_clang_atomic_t(const T &x) noexcept;
  operator T() volatile noexcept;
  operator T() noexcept;
};
# 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
# 70 "/usr/local/cuda/include/driver_types.h"
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/limits.h" 1 3 4
# 37 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 63 "/usr/include/limits.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 506 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_symbol_aliasing.h" 1 3 4
# 507 "/usr/include/sys/cdefs.h" 2 3 4
# 572 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/sys/_posix_availability.h" 1 3 4
# 573 "/usr/include/sys/cdefs.h" 2 3 4
# 64 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/machine/limits.h" 1 3 4





# 1 "/usr/include/i386/limits.h" 1 3 4
# 40 "/usr/include/i386/limits.h" 3 4
# 1 "/usr/include/i386/_limits.h" 1 3 4
# 41 "/usr/include/i386/limits.h" 2 3 4
# 7 "/usr/include/machine/limits.h" 2 3 4
# 65 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/sys/syslimits.h" 1 3 4
# 66 "/usr/include/limits.h" 2 3 4
# 38 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/limits.h" 2 3 4
# 71 "/usr/local/cuda/include/driver_types.h" 2
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stddef.h" 1 3 4
# 47 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 58 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 119 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stddef.h" 3 4
typedef long double max_align_t;
# 72 "/usr/local/cuda/include/driver_types.h" 2
# 150 "/usr/local/cuda/include/driver_types.h"
enum __attribute__((device_builtin)) cudaError
{





    cudaSuccess = 0,





    cudaErrorMissingConfiguration = 1,





    cudaErrorMemoryAllocation = 2,





    cudaErrorInitializationError = 3,
# 185 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchFailure = 4,
# 194 "/usr/local/cuda/include/driver_types.h"
    cudaErrorPriorLaunchFailure = 5,
# 204 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchTimeout = 6,
# 213 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchOutOfResources = 7,





    cudaErrorInvalidDeviceFunction = 8,
# 228 "/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,
# 309 "/usr/local/cuda/include/driver_types.h"
    cudaErrorAddressOfConstant = 22,
# 318 "/usr/local/cuda/include/driver_types.h"
    cudaErrorTextureFetchFailed = 23,
# 327 "/usr/local/cuda/include/driver_types.h"
    cudaErrorTextureNotBound = 24,
# 336 "/usr/local/cuda/include/driver_types.h"
    cudaErrorSynchronizationError = 25,





    cudaErrorInvalidFilterSetting = 26,





    cudaErrorInvalidNormSetting = 27,







    cudaErrorMixedDeviceExecution = 28,






    cudaErrorCudartUnloading = 29,




    cudaErrorUnknown = 30,







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






    cudaErrorInvalidResourceHandle = 33,







    cudaErrorNotReady = 34,






    cudaErrorInsufficientDriver = 35,
# 420 "/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,
# 482 "/usr/local/cuda/include/driver_types.h"
    cudaErrorDevicesUnavailable = 46,




    cudaErrorInvalidKernelImage = 47,







    cudaErrorNoKernelImageForDevice = 48,
# 508 "/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,
# 633 "/usr/local/cuda/include/driver_types.h"
    cudaErrorSyncDepthExceeded = 68,
# 645 "/usr/local/cuda/include/driver_types.h"
    cudaErrorLaunchPendingCountExceeded = 69,




    cudaErrorNotPermitted = 70,





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







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







    cudaErrorInvalidPc = 76,







    cudaErrorIllegalAddress = 77,





    cudaErrorInvalidPtx = 78,




    cudaErrorInvalidGraphicsContext = 79,





    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;
# 1033 "/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;
};




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




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;
};
# 1397 "/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;
# 1419 "/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;
# 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;



    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
# 1 "/usr/local/cuda/include/vector_types.h" 1
# 61 "/usr/local/cuda/include/vector_types.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 64 "/usr/local/cuda/include/builtin_types.h"
# 1 "/usr/local/cuda/include/vector_types.h" 1
# 65 "/usr/local/cuda/include/builtin_types.h" 2
# 62 "/usr/local/cuda/include/vector_types.h" 2
# 98 "/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;
};
# 274 "/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;
};
# 362 "/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;
# 65 "/usr/local/cuda/include/builtin_types.h" 2
# 71 "/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
# 143 "/usr/local/cuda/include/cuda_runtime_api.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 144 "/usr/local/cuda/include/cuda_runtime_api.h" 2
# 1 "/usr/local/cuda/include/cuda_device_runtime_api.h" 1
# 145 "/usr/local/cuda/include/cuda_runtime_api.h" 2
# 224 "/usr/local/cuda/include/cuda_runtime_api.h"
extern "C" {
# 257 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceReset(void);
# 274 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceSynchronize(void);
# 349 "/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);
# 409 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetCacheConfig(enum cudaFuncCache *pCacheConfig);
# 444 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority);
# 486 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceSetCacheConfig(enum cudaFuncCache cacheConfig);
# 515 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetSharedMemConfig(enum cudaSharedMemConfig *pConfig);
# 557 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceSetSharedMemConfig(enum cudaSharedMemConfig config);
# 580 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceGetByPCIBusId(int *device, const char *pciBusId);
# 607 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceGetPCIBusId(char *pciBusId, int len, int device);
# 649 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t *handle, cudaEvent_t event);
# 684 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcOpenEventHandle(cudaEvent_t *event, cudaIpcEventHandle_t handle);
# 722 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t *handle, void *devPtr);
# 772 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcOpenMemHandle(void **devPtr, cudaIpcMemHandle_t handle, unsigned int flags);
# 802 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaIpcCloseMemHandle(void *devPtr);
# 842 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadExit(void);
# 866 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadSynchronize(void);
# 913 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadSetLimit(enum cudaLimit limit, size_t value);
# 944 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadGetLimit(size_t *pValue, enum cudaLimit limit);
# 979 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadGetCacheConfig(enum cudaFuncCache *pCacheConfig);
# 1025 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaThreadSetCacheConfig(enum cudaFuncCache cacheConfig);
# 1079 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetLastError(void);
# 1120 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaPeekAtLastError(void);
# 1135 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorName(cudaError_t error);
# 1150 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) const char* cudaGetErrorString(cudaError_t error);
# 1180 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceCount(int *count);
# 1416 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device);
# 1576 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaDeviceGetAttribute(int *value, enum cudaDeviceAttr attr, int device);
# 1595 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaChooseDevice(int *device, const struct cudaDeviceProp *prop);
# 1629 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDevice(int device);
# 1646 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaGetDevice(int *device);
# 1675 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetValidDevices(int *device_arr, int len);
# 1737 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDeviceFlags( unsigned int flags );
# 1778 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetDeviceFlags( unsigned int *flags );
# 1815 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamCreate(cudaStream_t *pStream);
# 1844 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamCreateWithFlags(cudaStream_t *pStream, unsigned int flags);
# 1887 "/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);
# 1911 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int *priority);
# 1932 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int *flags);
# 1953 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaStreamDestroy(cudaStream_t stream);
# 1985 "/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);
# 1999 "/usr/local/cuda/include/cuda_runtime_api.h"
typedef void ( *cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void *userData);
# 2056 "/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);
# 2076 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamSynchronize(cudaStream_t stream);
# 2097 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaStreamQuery(cudaStream_t stream);
# 2163 "/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, unsigned int flags);
# 2199 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventCreate(cudaEvent_t *event);
# 2233 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventCreateWithFlags(cudaEvent_t *event, unsigned int flags);
# 2264 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream = 0);
# 2296 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventQuery(cudaEvent_t event);
# 2328 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventSynchronize(cudaEvent_t event);
# 2353 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaEventDestroy(cudaEvent_t event);
# 2394 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaEventElapsedTime(float *ms, cudaEvent_t start, cudaEvent_t end);
# 2450 "/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);
# 2499 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFuncSetCacheConfig(const void *func, enum cudaFuncCache cacheConfig);
# 2550 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFuncSetSharedMemConfig(const void *func, enum cudaSharedMemConfig config);
# 2583 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFuncGetAttributes(struct cudaFuncAttributes *attr, const void *func);
# 2604 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDoubleForDevice(double *d);
# 2625 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetDoubleForHost(double *d);
# 2681 "/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);
# 2725 "/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);
# 2776 "/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);
# 2805 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaSetupArgument(const void *arg, size_t size, size_t offset);
# 2842 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaLaunch(const void *func);
# 2931 "/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);
# 2957 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaMalloc(void **devPtr, size_t size);
# 2986 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMallocHost(void **ptr, size_t size);
# 3025 "/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);
# 3067 "/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);
# 3094 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) __attribute__((cudart_builtin)) cudaError_t cudaFree(void *devPtr);
# 3114 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFreeHost(void *ptr);
# 3136 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFreeArray(cudaArray_t array);
# 3158 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray);
# 3217 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostAlloc(void **pHost, size_t size, unsigned int flags);
# 3274 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostRegister(void *ptr, size_t size, unsigned int flags);
# 3293 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostUnregister(void *ptr);
# 3320 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags);
# 3339 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaHostGetFlags(unsigned int *pFlags, void *pHost);
# 3374 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMalloc3D(struct cudaPitchedPtr* pitchedDevPtr, struct cudaExtent extent);
# 3509 "/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);
# 3630 "/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);
# 3656 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t *levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level);
# 3753 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy3D(const struct cudaMemcpy3DParms *p);
# 3781 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy3DPeer(const struct cudaMemcpy3DPeerParms *p);
# 3889 "/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);
# 3912 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemcpy3DPeerAsync(const struct cudaMemcpy3DPeerParms *p, cudaStream_t stream = 0);
# 3931 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemGetInfo(size_t *free, size_t *total);
# 3952 "/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);
# 3987 "/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);
# 4019 "/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);
# 4053 "/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);
# 4087 "/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);
# 4122 "/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);
# 4164 "/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);
# 4206 "/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);
# 4248 "/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);
# 4288 "/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);
# 4323 "/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);
# 4358 "/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);
# 4404 "/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);
# 4436 "/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);
# 4478 "/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);
# 4520 "/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);
# 4575 "/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);
# 4626 "/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);
# 4676 "/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);
# 4719 "/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);
# 4762 "/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);
# 4788 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemset(void *devPtr, int value, size_t count);
# 4818 "/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);
# 4861 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaMemset3D(struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent);
# 4893 "/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);
# 4930 "/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);
# 4980 "/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);
# 5003 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSymbolAddress(void **devPtr, const void *symbol);
# 5025 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSymbolSize(size_t *size, const void *symbol);
# 5178 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaPointerGetAttributes(struct cudaPointerAttributes *attributes, const void *ptr);
# 5216 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceCanAccessPeer(int *canAccessPeer, int device, int peerDevice);
# 5253 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags);
# 5272 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDeviceDisablePeerAccess(int peerDevice);
# 5330 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource);
# 5362 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags);
# 5398 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0);
# 5430 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t *resources, cudaStream_t stream = 0);
# 5459 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, cudaGraphicsResource_t resource);
# 5493 "/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);
# 5518 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cudaGraphicsResource_t resource);
# 5558 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetChannelDesc(struct cudaChannelFormatDesc *desc, cudaArray_const_t array);
# 5593 "/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);
# 5640 "/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 = (2147483647 *2U +1U));
# 5691 "/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);
# 5719 "/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);
# 5747 "/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);
# 5768 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaUnbindTexture(const struct textureReference *texref);
# 5793 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureAlignmentOffset(size_t *offset, const struct textureReference *texref);
# 5818 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureReference(const struct textureReference **texref, const void *symbol);
# 5858 "/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);
# 5877 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSurfaceReference(const struct surfaceReference **surfref, const void *symbol);
# 6094 "/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);
# 6109 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject);
# 6125 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaTextureObject_t texObject);
# 6141 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureObjectTextureDesc(struct cudaTextureDesc *pTexDesc, cudaTextureObject_t texObject);
# 6158 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetTextureObjectResourceViewDesc(struct cudaResourceViewDesc *pResViewDesc, cudaTextureObject_t texObject);
# 6197 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t *pSurfObject, const struct cudaResourceDesc *pResDesc);
# 6212 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject);
# 6227 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaGetSurfaceObjectResourceDesc(struct cudaResourceDesc *pResDesc, cudaSurfaceObject_t surfObject);
# 6254 "/usr/local/cuda/include/cuda_runtime_api.h"
extern __attribute__((host)) cudaError_t cudaDriverGetVersion(int *driverVersion);
# 6271 "/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);
# 6500 "/usr/local/cuda/include/cuda_runtime_api.h"
}
# 63 "/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);
}
# 74 "/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
# 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;
}
# 76 "/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
# 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
# 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
# 80 "/usr/local/cuda/include/cuda_runtime.h" 2
# 104 "/usr/local/cuda/include/cuda_runtime.h"
# 1 "/usr/local/cuda/include/common_functions.h" 1
# 61 "/usr/local/cuda/include/common_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 62 "/usr/local/cuda/include/common_functions.h" 2



# 1 "/usr/include/string.h" 1 3 4
# 61 "/usr/include/string.h" 3 4
# 1 "/usr/include/_types.h" 1 3 4
# 27 "/usr/include/_types.h" 3 4
# 1 "/usr/include/sys/_types.h" 1 3 4
# 33 "/usr/include/sys/_types.h" 3 4
# 1 "/usr/include/machine/_types.h" 1 3 4
# 32 "/usr/include/machine/_types.h" 3 4
# 1 "/usr/include/i386/_types.h" 1 3 4
# 37 "/usr/include/i386/_types.h" 3 4
typedef signed char __int8_t;



typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;

typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
# 70 "/usr/include/i386/_types.h" 3 4
typedef int __darwin_ct_rune_t;





typedef union {
 char __mbstate8[128];
 long long _mbstateL;
} __mbstate_t;

typedef __mbstate_t __darwin_mbstate_t;


typedef long int __darwin_ptrdiff_t;







typedef long unsigned int __darwin_size_t;





typedef __builtin_va_list __darwin_va_list;





typedef int __darwin_wchar_t;




typedef __darwin_wchar_t __darwin_rune_t;


typedef int __darwin_wint_t;




typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
# 33 "/usr/include/machine/_types.h" 2 3 4
# 34 "/usr/include/sys/_types.h" 2 3 4
# 55 "/usr/include/sys/_types.h" 3 4
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;

typedef __darwin_ino64_t __darwin_ino_t;



typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];


# 1 "/usr/include/sys/_pthread/_pthread_types.h" 1 3 4
# 57 "/usr/include/sys/_pthread/_pthread_types.h" 3 4
struct __darwin_pthread_handler_rec {
 void (*__routine)(void *);
 void *__arg;
 struct __darwin_pthread_handler_rec *__next;
};

struct _opaque_pthread_attr_t {
 long __sig;
 char __opaque[56];
};

struct _opaque_pthread_cond_t {
 long __sig;
 char __opaque[40];
};

struct _opaque_pthread_condattr_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_mutex_t {
 long __sig;
 char __opaque[56];
};

struct _opaque_pthread_mutexattr_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_once_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_rwlock_t {
 long __sig;
 char __opaque[192];
};

struct _opaque_pthread_rwlockattr_t {
 long __sig;
 char __opaque[16];
};

struct _opaque_pthread_t {
 long __sig;
 struct __darwin_pthread_handler_rec *__cleanup_stack;
 char __opaque[8176];
};

typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
# 81 "/usr/include/sys/_types.h" 2 3 4
# 28 "/usr/include/_types.h" 2 3 4
# 39 "/usr/include/_types.h" 3 4
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;

typedef __uint32_t __darwin_wctype_t;
# 62 "/usr/include/string.h" 2 3 4

# 1 "/usr/include/Availability.h" 1 3 4
# 153 "/usr/include/Availability.h" 3 4
# 1 "/usr/include/AvailabilityInternal.h" 1 3 4
# 154 "/usr/include/Availability.h" 2 3 4
# 64 "/usr/include/string.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 65 "/usr/include/string.h" 2 3 4
# 1 "/usr/include/sys/_types/_null.h" 1 3 4
# 66 "/usr/include/string.h" 2 3 4



extern "C" {
void *memchr(const void *, int, size_t);
int memcmp(const void *, const void *, size_t);
void *memcpy(void *, const void *, size_t);
void *memmove(void *, const void *, size_t);
void *memset(void *, int, size_t);
char *strcat(char *, const char *);
char *strchr(const char *, int);
int strcmp(const char *, const char *);
int strcoll(const char *, const char *);
char *strcpy(char *, const char *);
size_t strcspn(const char *, const char *);
char *strerror(int) __asm("_" "strerror" );
size_t strlen(const char *);
char *strncat(char *, const char *, size_t);
int strncmp(const char *, const char *, size_t);
char *strncpy(char *, const char *, size_t);
char *strpbrk(const char *, const char *);
char *strrchr(const char *, int);
size_t strspn(const char *, const char *);
char *strstr(const char *, const char *);
char *strtok(char *, const char *);
size_t strxfrm(char *, const char *, size_t);
}
# 103 "/usr/include/string.h" 3 4
extern "C" {
char *strtok_r(char *, const char *, char **);
}
# 115 "/usr/include/string.h" 3 4
extern "C" {
int strerror_r(int, char *, size_t);
char *strdup(const char *);
void *memccpy(void *, const void *, int, size_t);
}
# 129 "/usr/include/string.h" 3 4
extern "C" {
char *stpcpy(char *, const char *);
char *stpncpy(char *, const char *, size_t) __attribute__((availability(macosx,introduced=10.7)));
char *strndup(const char *, size_t) __attribute__((availability(macosx,introduced=10.7)));
size_t strnlen(const char *, size_t) __attribute__((availability(macosx,introduced=10.7)));
char *strsignal(int sig);
}
# 152 "/usr/include/string.h" 3 4
# 1 "/usr/include/sys/_types/_ssize_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_ssize_t.h" 3 4
typedef __darwin_ssize_t ssize_t;
# 153 "/usr/include/string.h" 2 3 4

extern "C" {
void *memmem(const void *, size_t, const void *, size_t) __attribute__((availability(macosx,introduced=10.7)));
void memset_pattern4(void *, const void *, size_t) __attribute__((availability(macosx,introduced=10.5)));
void memset_pattern8(void *, const void *, size_t) __attribute__((availability(macosx,introduced=10.5)));
void memset_pattern16(void *, const void *, size_t) __attribute__((availability(macosx,introduced=10.5)));

char *strcasestr(const char *, const char *);
char *strnstr(const char *, const char *, size_t);
size_t strlcat(char *, const char *, size_t);
size_t strlcpy(char *, const char *, size_t);
void strmode(int, char *);
char *strsep(char **, const char *);


void swab(const void * , void * , ssize_t);
}







# 1 "/usr/include/strings.h" 1 3 4
# 65 "/usr/include/strings.h" 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 66 "/usr/include/strings.h" 2 3 4

extern "C" {


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


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



extern "C" {
int ffsl(long) __attribute__((availability(macosx,introduced=10.5)));
int ffsll(long long) __attribute__((availability(macosx,introduced=10.9)));
int fls(int) __attribute__((availability(macosx,introduced=10.5)));
int flsl(long) __attribute__((availability(macosx,introduced=10.5)));
int flsll(long long) __attribute__((availability(macosx,introduced=10.9)));
}


# 1 "/usr/include/string.h" 1 3 4
# 93 "/usr/include/strings.h" 2 3 4
# 177 "/usr/include/string.h" 2 3 4
# 66 "/usr/local/cuda/include/common_functions.h" 2
# 1 "/usr/include/time.h" 1 3 4
# 67 "/usr/include/time.h" 3 4
# 1 "/usr/include/sys/_types/_clock_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_clock_t.h" 3 4
typedef __darwin_clock_t clock_t;
# 68 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/sys/_types/_null.h" 1 3 4
# 69 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 70 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/sys/_types/_time_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_time_t.h" 3 4
typedef __darwin_time_t time_t;
# 71 "/usr/include/time.h" 2 3 4
# 1 "/usr/include/sys/_types/_timespec.h" 1 3 4
# 30 "/usr/include/sys/_types/_timespec.h" 3 4
struct timespec
{
 __darwin_time_t tv_sec;
 long tv_nsec;
};
# 72 "/usr/include/time.h" 2 3 4

struct tm {
 int tm_sec;
 int tm_min;
 int tm_hour;
 int tm_mday;
 int tm_mon;
 int tm_year;
 int tm_wday;
 int tm_yday;
 int tm_isdst;
 long tm_gmtoff;
 char *tm_zone;
};
# 96 "/usr/include/time.h" 3 4
extern char *tzname[];


extern int getdate_err;

extern long timezone __asm("_" "timezone" );

extern int daylight;

extern "C" {
char *asctime(const struct tm *);
clock_t clock(void) __asm("_" "clock" );
char *ctime(const time_t *);
double difftime(time_t, time_t);
struct tm *getdate(const char *);
struct tm *gmtime(const time_t *);
struct tm *localtime(const time_t *);
time_t mktime(struct tm *) __asm("_" "mktime" );
size_t strftime(char * , size_t, const char * , const struct tm * ) __asm("_" "strftime" );
char *strptime(const char * , const char * , struct tm * ) __asm("_" "strptime" );
time_t time(time_t *);


void tzset(void);



char *asctime_r(const struct tm * , char * );
char *ctime_r(const time_t *, char *);
struct tm *gmtime_r(const time_t * , struct tm * );
struct tm *localtime_r(const time_t * , struct tm * );


time_t posix2time(time_t);



void tzsetwall(void);
time_t time2posix(time_t);
time_t timelocal(struct tm * const);
time_t timegm(struct tm * const);



int nanosleep(const struct timespec *, struct timespec *) __asm("_" "nanosleep" );

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

extern "C"
{

extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) clock_t clock(void) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memset(void*, int, size_t) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void* memcpy(void*, const void*, size_t) ;

}
# 87 "/usr/local/cuda/include/common_functions.h"
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/new" 1 3
# 67 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/new" 3
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__config" 1 3
# 16 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__config" 3
# 360 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/__config" 3
namespace std {
  inline namespace __1 {
  }
}
# 68 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/new" 2 3
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/exception" 1 3
# 80 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/exception" 3
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstddef" 1 3
# 38 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstddef" 3
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stddef.h" 1 3 4
# 39 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstddef" 2 3
# 42 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstddef" 3


namespace std {inline namespace __1 {

using ::ptrdiff_t;
using ::size_t;



using ::max_align_t;
# 91 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstddef" 3
} }



namespace std
{
    typedef decltype(nullptr) nullptr_t;
}
# 81 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/exception" 2 3
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 1 3
# 208 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3


namespace std {inline namespace __1 {

template <bool _Bp, class _If, class _Then>
    struct __attribute__ ((__type_visibility__("default"))) conditional {typedef _If type;};
template <class _If, class _Then>
    struct __attribute__ ((__type_visibility__("default"))) conditional<false, _If, _Then> {typedef _Then type;};





template <bool, class _Tp = void> struct __attribute__ ((__type_visibility__("default"))) enable_if {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) enable_if<true, _Tp> {typedef _Tp type;};






struct __two {char __lx[2];};



template <class _Tp, _Tp __v>
struct __attribute__ ((__type_visibility__("default"))) integral_constant
{
    static constexpr const _Tp value = __v;
    typedef _Tp value_type;
    typedef integral_constant type;
    __attribute__ ((__visibility__("hidden"), __always_inline__))
        constexpr operator value_type() const noexcept {return value;}




};

template <class _Tp, _Tp __v>
constexpr const _Tp integral_constant<_Tp, __v>::value;

typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_const : public false_type {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_const<_Tp const> : public true_type {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_volatile : public false_type {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_volatile<_Tp volatile> : public true_type {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_const {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_const<const _Tp> {typedef _Tp type;};






template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_volatile {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_volatile<volatile _Tp> {typedef _Tp type;};






template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_cv
{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};






template <class _Tp> struct __libcpp_is_void : public false_type {};
template <> struct __libcpp_is_void<void> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_void
    : public __libcpp_is_void<typename remove_cv<_Tp>::type> {};



template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) __is_nullptr_t
    : public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};
# 310 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __libcpp_is_integral : public false_type {};
template <> struct __libcpp_is_integral<bool> : public true_type {};
template <> struct __libcpp_is_integral<char> : public true_type {};
template <> struct __libcpp_is_integral<signed char> : public true_type {};
template <> struct __libcpp_is_integral<unsigned char> : public true_type {};
template <> struct __libcpp_is_integral<wchar_t> : public true_type {};

template <> struct __libcpp_is_integral<char16_t> : public true_type {};
template <> struct __libcpp_is_integral<char32_t> : public true_type {};

template <> struct __libcpp_is_integral<short> : public true_type {};
template <> struct __libcpp_is_integral<unsigned short> : public true_type {};
template <> struct __libcpp_is_integral<int> : public true_type {};
template <> struct __libcpp_is_integral<unsigned int> : public true_type {};
template <> struct __libcpp_is_integral<long> : public true_type {};
template <> struct __libcpp_is_integral<unsigned long> : public true_type {};
template <> struct __libcpp_is_integral<long long> : public true_type {};
template <> struct __libcpp_is_integral<unsigned long long> : public true_type {};

template <> struct __libcpp_is_integral<__int128_t> : public true_type {};
template <> struct __libcpp_is_integral<__uint128_t> : public true_type {};


template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_integral
    : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};



template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
template <> struct __libcpp_is_floating_point<float> : public true_type {};
template <> struct __libcpp_is_floating_point<double> : public true_type {};
template <> struct __libcpp_is_floating_point<long double> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_floating_point
    : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_array
    : public false_type {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_array<_Tp[]>
    : public true_type {};
template <class _Tp, size_t _Np> struct __attribute__ ((__type_visibility__("default"))) is_array<_Tp[_Np]>
    : public true_type {};



template <class _Tp> struct __libcpp_is_pointer : public false_type {};
template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_pointer
    : public __libcpp_is_pointer<typename remove_cv<_Tp>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_lvalue_reference : public false_type {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_lvalue_reference<_Tp&> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_rvalue_reference : public false_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_rvalue_reference<_Tp&&> : public true_type {};


template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_reference : public false_type {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_reference<_Tp&> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_reference<_Tp&&> : public true_type {};






template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_union
    : public integral_constant<bool, __is_union(_Tp)> {};
# 398 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_class
    : public integral_constant<bool, __is_class(_Tp)> {};
# 416 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp, class _Up> struct __attribute__ ((__type_visibility__("default"))) is_same : public false_type {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_same<_Tp, _Tp> : public true_type {};



namespace __libcpp_is_function_imp
{
template <class _Tp> char __test(_Tp*);
template <class _Tp> __two __test(...);
template <class _Tp> _Tp& __source();
}

template <class _Tp, bool = is_class<_Tp>::value ||
                            is_union<_Tp>::value ||
                            is_void<_Tp>::value ||
                            is_reference<_Tp>::value ||
                            __is_nullptr_t<_Tp>::value >
struct __libcpp_is_function
    : public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>())) == 1>
    {};
template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_function
    : public __libcpp_is_function<_Tp> {};







template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
struct __member_pointer_traits_imp
{
};


namespace __libcpp_is_member_function_pointer_imp {
    template <typename _Tp>
    char __test(typename std::__member_pointer_traits_imp<_Tp, true, false>::_FnType *);

    template <typename>
    std::__two __test(...);
};

template <class _Tp> struct __libcpp_is_member_function_pointer
    : public integral_constant<bool, sizeof(__libcpp_is_member_function_pointer_imp::__test<_Tp>(nullptr)) == 1> {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_member_function_pointer
    : public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type> {};



template <class _Tp> struct __libcpp_is_member_pointer : public false_type {};
template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> : public true_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_member_pointer
    : public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_member_object_pointer
    : public integral_constant<bool, is_member_pointer<_Tp>::value &&
                                    !is_member_function_pointer<_Tp>::value> {};





template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_enum
    : public integral_constant<bool, __is_enum(_Tp)> {};
# 506 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_arithmetic
    : public integral_constant<bool, is_integral<_Tp>::value ||
                                     is_floating_point<_Tp>::value> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_fundamental
    : public integral_constant<bool, is_void<_Tp>::value ||
                                     __is_nullptr_t<_Tp>::value ||
                                     is_arithmetic<_Tp>::value> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_scalar
    : public integral_constant<bool, is_arithmetic<_Tp>::value ||
                                     is_member_pointer<_Tp>::value ||
                                     is_pointer<_Tp>::value ||
                                     __is_nullptr_t<_Tp>::value ||
                                     is_enum<_Tp>::value > {};

template <> struct __attribute__ ((__type_visibility__("default"))) is_scalar<nullptr_t> : public true_type {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_object
    : public integral_constant<bool, is_scalar<_Tp>::value ||
                                     is_array<_Tp>::value ||
                                     is_union<_Tp>::value ||
                                     is_class<_Tp>::value > {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_compound
    : public integral_constant<bool, !is_fundamental<_Tp>::value> {};



template <class _Tp, bool = is_reference<_Tp>::value ||
                            is_function<_Tp>::value ||
                            is_const<_Tp>::value >
struct __add_const {typedef _Tp type;};

template <class _Tp>
struct __add_const<_Tp, false> {typedef const _Tp type;};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_const
    {typedef typename __add_const<_Tp>::type type;};







template <class _Tp, bool = is_reference<_Tp>::value ||
                            is_function<_Tp>::value ||
                            is_volatile<_Tp>::value >
struct __add_volatile {typedef _Tp type;};

template <class _Tp>
struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_volatile
    {typedef typename __add_volatile<_Tp>::type type;};







template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_cv
    {typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};







template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_reference {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_reference<_Tp&> {typedef _Tp type;};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_reference<_Tp&&> {typedef _Tp type;};
# 598 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_lvalue_reference {typedef _Tp& type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_lvalue_reference<_Tp&> {typedef _Tp& type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_lvalue_reference<void> {typedef void type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_lvalue_reference<const void> {typedef const void type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_lvalue_reference<volatile void> {typedef volatile void type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_lvalue_reference<const volatile void> {typedef const volatile void type;};







template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_rvalue_reference {typedef _Tp&& type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_rvalue_reference<void> {typedef void type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_rvalue_reference<const void> {typedef const void type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_rvalue_reference<volatile void> {typedef volatile void type;};
template <> struct __attribute__ ((__type_visibility__("default"))) add_rvalue_reference<const volatile void> {typedef const volatile void type;};
# 625 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
typename add_rvalue_reference<_Tp>::type
declval() noexcept;
# 637 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
struct __any
{
    __any(...);
};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_pointer {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp*> {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp* const> {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp* volatile> {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_pointer<_Tp* const volatile> {typedef _Tp type;};







template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) add_pointer
    {typedef typename remove_reference<_Tp>::type* type;};







template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_signed_impl : public integral_constant<bool, _Tp(-1) < _Tp(0)> {};

template <class _Tp>
struct __libcpp_is_signed_impl<_Tp, false> : public true_type {};

template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};

template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_signed : public __libcpp_is_signed<_Tp> {};



template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_unsigned_impl : public integral_constant<bool, _Tp(0) < _Tp(-1)> {};

template <class _Tp>
struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {};

template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};

template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_unsigned : public __libcpp_is_unsigned<_Tp> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) rank
    : public integral_constant<size_t, 0> {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) rank<_Tp[]>
    : public integral_constant<size_t, rank<_Tp>::value + 1> {};
template <class _Tp, size_t _Np> struct __attribute__ ((__type_visibility__("default"))) rank<_Tp[_Np]>
    : public integral_constant<size_t, rank<_Tp>::value + 1> {};



template <class _Tp, unsigned _Ip = 0> struct __attribute__ ((__type_visibility__("default"))) extent
    : public integral_constant<size_t, 0> {};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) extent<_Tp[], 0>
    : public integral_constant<size_t, 0> {};
template <class _Tp, unsigned _Ip> struct __attribute__ ((__type_visibility__("default"))) extent<_Tp[], _Ip>
    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
template <class _Tp, size_t _Np> struct __attribute__ ((__type_visibility__("default"))) extent<_Tp[_Np], 0>
    : public integral_constant<size_t, _Np> {};
template <class _Tp, size_t _Np, unsigned _Ip> struct __attribute__ ((__type_visibility__("default"))) extent<_Tp[_Np], _Ip>
    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_extent
    {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_extent<_Tp[]>
    {typedef _Tp type;};
template <class _Tp, size_t _Np> struct __attribute__ ((__type_visibility__("default"))) remove_extent<_Tp[_Np]>
    {typedef _Tp type;};







template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_all_extents
    {typedef _Tp type;};
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) remove_all_extents<_Tp[]>
    {typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp, size_t _Np> struct __attribute__ ((__type_visibility__("default"))) remove_all_extents<_Tp[_Np]>
    {typedef typename remove_all_extents<_Tp>::type type;};







template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) decay
{
private:
    typedef typename remove_reference<_Tp>::type _Up;
public:
    typedef typename conditional
                     <
                         is_array<_Up>::value,
                         typename remove_extent<_Up>::type*,
                         typename conditional
                         <
                              is_function<_Up>::value,
                              typename add_pointer<_Up>::type,
                              typename remove_cv<_Up>::type
                         >::type
                     >::type type;
};







namespace __is_abstract_imp
{
template <class _Tp> char __test(_Tp (*)[1]);
template <class _Tp> __two __test(...);
}

template <class _Tp, bool = is_class<_Tp>::value>
struct __libcpp_abstract : public integral_constant<bool, sizeof(__is_abstract_imp::__test<_Tp>(0)) != 1> {};

template <class _Tp> struct __libcpp_abstract<_Tp, false> : public false_type {};

template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_abstract : public __libcpp_abstract<_Tp> {};
# 792 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Bp, class _Dp>
struct __attribute__ ((__type_visibility__("default"))) is_base_of
    : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
# 827 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _T1, class _T2> struct __attribute__ ((__type_visibility__("default"))) is_convertible
    : public integral_constant<bool, __is_convertible_to(_T1, _T2) &&
                                     !is_abstract<_T2>::value> {};
# 946 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_empty
    : public integral_constant<bool, __is_empty(_Tp)> {};
# 977 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_polymorphic
    : public integral_constant<bool, __is_polymorphic(_Tp)> {};
# 997 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) has_virtual_destructor
    : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
# 1009 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) alignment_of
    : public integral_constant<size_t, __alignof__(_Tp)> {};



template <class _Hp, class _Tp>
struct __type_list
{
    typedef _Hp _Head;
    typedef _Tp _Tail;
};

struct __nat
{

    __nat() = delete;
    __nat(const __nat&) = delete;
    __nat& operator=(const __nat&) = delete;
    ~__nat() = delete;

};

template <class _Tp>
struct __align_type
{
    static const size_t value = alignment_of<_Tp>::value;
    typedef _Tp type;
};

struct __struct_double {long double __lx;};
struct __struct_double4 {double __lx[4];};

typedef
    __type_list<__align_type<unsigned char>,
    __type_list<__align_type<unsigned short>,
    __type_list<__align_type<unsigned int>,
    __type_list<__align_type<unsigned long>,
    __type_list<__align_type<unsigned long long>,
    __type_list<__align_type<double>,
    __type_list<__align_type<long double>,
    __type_list<__align_type<__struct_double>,
    __type_list<__align_type<__struct_double4>,
    __type_list<__align_type<int*>,
    __nat
    > > > > > > > > > > __all_types;

template <class _TL, size_t _Align> struct __find_pod;

template <class _Hp, size_t _Align>
struct __find_pod<__type_list<_Hp, __nat>, _Align>
{
    typedef typename conditional<
                             _Align == _Hp::value,
                             typename _Hp::type,
                             void
                         >::type type;
};

template <class _Hp, class _Tp, size_t _Align>
struct __find_pod<__type_list<_Hp, _Tp>, _Align>
{
    typedef typename conditional<
                             _Align == _Hp::value,
                             typename _Hp::type,
                             typename __find_pod<_Tp, _Align>::type
                         >::type type;
};

template <class _TL, size_t _Len> struct __find_max_align;

template <class _Hp, size_t _Len>
struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};

template <size_t _Len, size_t _A1, size_t _A2>
struct __select_align
{
private:
    static const size_t __min = _A2 < _A1 ? _A2 : _A1;
    static const size_t __max = _A1 < _A2 ? _A2 : _A1;
public:
    static const size_t value = _Len < __max ? __min : __max;
};

template <class _Hp, class _Tp, size_t _Len>
struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
    : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};

template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
struct __attribute__ ((__type_visibility__("default"))) aligned_storage
{
    typedef typename __find_pod<__all_types, _Align>::type _Aligner;
    static_assert(!is_void<_Aligner>::value, "");
    union type
    {
        _Aligner __align;
        unsigned char __data[_Len];
    };
};
# 1123 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x1>{ struct alignas(0x1) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x2>{ struct alignas(0x2) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x4>{ struct alignas(0x4) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x8>{ struct alignas(0x8) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x10>{ struct alignas(0x10) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x20>{ struct alignas(0x20) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x40>{ struct alignas(0x40) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x80>{ struct alignas(0x80) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x100>{ struct alignas(0x100) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x200>{ struct alignas(0x200) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x400>{ struct alignas(0x400) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x800>{ struct alignas(0x800) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x1000>{ struct alignas(0x1000) type { unsigned char __lx[_Len]; };};
template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x2000>{ struct alignas(0x2000) type { unsigned char __lx[_Len]; };};


template <size_t _Len>struct __attribute__ ((__type_visibility__("default"))) aligned_storage<_Len, 0x4000>{ struct alignas(0x4000) type { unsigned char __lx[_Len]; };};
# 1148 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <size_t _I0, size_t ..._In>
struct __static_max;

template <size_t _I0>
struct __static_max<_I0>
{
    static const size_t value = _I0;
};

template <size_t _I0, size_t _I1, size_t ..._In>
struct __static_max<_I0, _I1, _In...>
{
    static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
                                             __static_max<_I1, _In...>::value;
};

template <size_t _Len, class _Type0, class ..._Types>
struct aligned_union
{
    static const size_t alignment_value = __static_max<__alignof__(_Type0),
                                                       __alignof__(_Types)...>::value;
    static const size_t __len = __static_max<_Len, sizeof(_Type0),
                                             sizeof(_Types)...>::value;
    typedef typename aligned_storage<__len, alignment_value>::type type;
};







template <class _Tp>
struct __numeric_type
{
   static void __test(...);
   static float __test(float);
   static double __test(char);
   static double __test(int);
   static double __test(unsigned);
   static double __test(long);
   static double __test(unsigned long);
   static double __test(long long);
   static double __test(unsigned long long);
   static double __test(double);
   static long double __test(long double);

   typedef decltype(__test(declval<_Tp>())) type;
   static const bool value = !is_same<type, void>::value;
};

template <>
struct __numeric_type<void>
{
   static const bool value = true;
};



template <class _A1, class _A2 = void, class _A3 = void,
          bool = __numeric_type<_A1>::value &&
                 __numeric_type<_A2>::value &&
                 __numeric_type<_A3>::value>
class __promote
{
    static const bool value = false;
};

template <class _A1, class _A2, class _A3>
class __promote<_A1, _A2, _A3, true>
{
private:
    typedef typename __promote<_A1>::type __type1;
    typedef typename __promote<_A2>::type __type2;
    typedef typename __promote<_A3>::type __type3;
public:
    typedef decltype(__type1() + __type2() + __type3()) type;
    static const bool value = true;
};

template <class _A1, class _A2>
class __promote<_A1, _A2, void, true>
{
private:
    typedef typename __promote<_A1>::type __type1;
    typedef typename __promote<_A2>::type __type2;
public:
    typedef decltype(__type1() + __type2()) type;
    static const bool value = true;
};

template <class _A1>
class __promote<_A1, void, void, true>
{
public:
    typedef typename __numeric_type<_A1>::type type;
    static const bool value = true;
    static const bool __does_not_throw = noexcept(static_cast<type>(declval<_A1>()));
};
# 1262 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
typedef
    __type_list<signed char,
    __type_list<signed short,
    __type_list<signed int,
    __type_list<signed long,
    __type_list<signed long long,

    __type_list<__int128_t,

    __nat

    >

    > > > > > __signed_types;

typedef
    __type_list<unsigned char,
    __type_list<unsigned short,
    __type_list<unsigned int,
    __type_list<unsigned long,
    __type_list<unsigned long long,

    __type_list<__uint128_t,

    __nat

    >

    > > > > > __unsigned_types;

template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;

template <class _Hp, class _Tp, size_t _Size>
struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
{
    typedef _Hp type;
};

template <class _Hp, class _Tp, size_t _Size>
struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
{
    typedef typename __find_first<_Tp, _Size>::type type;
};

template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value,
                             bool = is_volatile<typename remove_reference<_Tp>::type>::value>
struct __apply_cv
{
    typedef _Up type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, false>
{
    typedef const _Up type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, false, true>
{
    typedef volatile _Up type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp, _Up, true, true>
{
    typedef const volatile _Up type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, false, false>
{
    typedef _Up& type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, true, false>
{
    typedef const _Up& type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, false, true>
{
    typedef volatile _Up& type;
};

template <class _Tp, class _Up>
struct __apply_cv<_Tp&, _Up, true, true>
{
    typedef const volatile _Up& type;
};

template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
struct __make_signed {};

template <class _Tp>
struct __make_signed<_Tp, true>
{
    typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
};

template <> struct __make_signed<bool, true> {};
template <> struct __make_signed< signed short, true> {typedef short type;};
template <> struct __make_signed<unsigned short, true> {typedef short type;};
template <> struct __make_signed< signed int, true> {typedef int type;};
template <> struct __make_signed<unsigned int, true> {typedef int type;};
template <> struct __make_signed< signed long, true> {typedef long type;};
template <> struct __make_signed<unsigned long, true> {typedef long type;};
template <> struct __make_signed< signed long long, true> {typedef long long type;};
template <> struct __make_signed<unsigned long long, true> {typedef long long type;};

template <> struct __make_signed<__int128_t, true> {typedef __int128_t type;};
template <> struct __make_signed<__uint128_t, true> {typedef __int128_t type;};


template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) make_signed
{
    typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
};





template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
struct __make_unsigned {};

template <class _Tp>
struct __make_unsigned<_Tp, true>
{
    typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
};

template <> struct __make_unsigned<bool, true> {};
template <> struct __make_unsigned< signed short, true> {typedef unsigned short type;};
template <> struct __make_unsigned<unsigned short, true> {typedef unsigned short type;};
template <> struct __make_unsigned< signed int, true> {typedef unsigned int type;};
template <> struct __make_unsigned<unsigned int, true> {typedef unsigned int type;};
template <> struct __make_unsigned< signed long, true> {typedef unsigned long type;};
template <> struct __make_unsigned<unsigned long, true> {typedef unsigned long type;};
template <> struct __make_unsigned< signed long long, true> {typedef unsigned long long type;};
template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};

template <> struct __make_unsigned<__int128_t, true> {typedef __uint128_t type;};
template <> struct __make_unsigned<__uint128_t, true> {typedef __uint128_t type;};


template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) make_unsigned
{
    typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
};
# 1454 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class ..._Tp> struct common_type;

template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) common_type<_Tp>
{
    typedef typename decay<_Tp>::type type;
};

template <class _Tp, class _Up>
struct __attribute__ ((__type_visibility__("default"))) common_type<_Tp, _Up>
{
private:
    static _Tp&& __t();
    static _Up&& __u();
    static bool __f();
public:
    typedef typename decay<decltype(__f() ? __t() : __u())>::type type;
};

template <class _Tp, class _Up, class ..._Vp>
struct __attribute__ ((__type_visibility__("default"))) common_type<_Tp, _Up, _Vp...>
{
    typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
};
# 1487 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template<typename, typename _Tp> struct __select_2nd { typedef _Tp type; };

template <class _Tp, class _Arg>
typename __select_2nd<decltype((std::__1::declval<_Tp>() = std::__1::declval<_Arg>())), true_type>::type

__is_assignable_test(_Tp&&, _Arg&&);




template <class _Arg>
false_type

__is_assignable_test(__any, _Arg&&);




template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
struct __is_assignable_imp
    : public common_type
        <
            decltype(__is_assignable_test(declval<_Tp>(), declval<_Arg>()))
        >::type {};

template <class _Tp, class _Arg>
struct __is_assignable_imp<_Tp, _Arg, true>
    : public false_type
{
};

template <class _Tp, class _Arg>
struct is_assignable
    : public __is_assignable_imp<_Tp, _Arg> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_copy_assignable
    : public is_assignable<typename add_lvalue_reference<_Tp>::type,
                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_move_assignable

    : public is_assignable<typename add_lvalue_reference<_Tp>::type,
                     const typename add_rvalue_reference<_Tp>::type> {};
# 1547 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class>
struct __is_destructible_apply { typedef int type; };

template <typename _Tp>
struct __is_destructor_wellformed {
 template <typename _Tp1>
 static char __test (
        typename __is_destructible_apply<decltype(std::__1::declval<_Tp1&>().~_Tp1())>::type
    );

 template <typename _Tp1>
 static __two __test (...);

 static const bool value = sizeof(__test<_Tp>(12)) == sizeof(char);
};

template <class _Tp, bool>
struct __destructible_imp;

template <class _Tp>
struct __destructible_imp<_Tp, false>
   : public std::__1::integral_constant<bool,
        __is_destructor_wellformed<typename std::__1::remove_all_extents<_Tp>::type>::value> {};

template <class _Tp>
struct __destructible_imp<_Tp, true>
    : public std::__1::true_type {};

template <class _Tp, bool>
struct __destructible_false;

template <class _Tp>
struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, std::__1::is_reference<_Tp>::value> {};

template <class _Tp>
struct __destructible_false<_Tp, true> : public std::__1::false_type {};

template <class _Tp>
struct is_destructible
    : public __destructible_false<_Tp, std::__1::is_function<_Tp>::value> {};

template <class _Tp>
struct is_destructible<_Tp[]>
    : public std::__1::false_type {};

template <>
struct is_destructible<void>
    : public std::__1::false_type {};





template <class _Tp>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{
    typedef typename remove_reference<_Tp>::type _Up;
    return static_cast<_Up&&>(__t);
}

template <class _Tp>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
_Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{
    return static_cast<_Tp&&>(__t);
}

template <class _Tp>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
_Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
    static_assert(!std::is_lvalue_reference<_Tp>::value,
                  "Can not forward an rvalue as an lvalue.");
    return static_cast<_Tp&&>(__t);
}
# 1670 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename decay<_Tp>::type
__decay_copy(_Tp&& __t)
{
    return std::__1::forward<_Tp>(__t);
}
# 1692 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
{
    typedef _Class _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...), true, false>
{
    typedef _Class _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false>
{
    typedef _Class const _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const, true, false>
{
    typedef _Class const _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false>
{
    typedef _Class volatile _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile, true, false>
{
    typedef _Class volatile _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false>
{
    typedef _Class const volatile _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile, true, false>
{
    typedef _Class const volatile _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};



template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false>
{
    typedef _Class& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &, true, false>
{
    typedef _Class& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&, true, false>
{
    typedef _Class const& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&, true, false>
{
    typedef _Class const& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&, true, false>
{
    typedef _Class volatile& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&, true, false>
{
    typedef _Class volatile& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&, true, false>
{
    typedef _Class const volatile& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&, true, false>
{
    typedef _Class const volatile& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false>
{
    typedef _Class&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &&, true, false>
{
    typedef _Class&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&&, true, false>
{
    typedef _Class const&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&&, true, false>
{
    typedef _Class const&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&&, true, false>
{
    typedef _Class volatile&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&&, true, false>
{
    typedef _Class volatile&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&&, true, false>
{
    typedef _Class const volatile&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param...);
};

template <class _Rp, class _Class, class ..._Param>
struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&&, true, false>
{
    typedef _Class const volatile&& _ClassType;
    typedef _Rp _ReturnType;
    typedef _Rp (_FnType) (_Param..., ...);
};
# 2148 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Rp, class _Class>
struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
{
    typedef _Class _ClassType;
    typedef _Rp _ReturnType;
};

template <class _MP>
struct __member_pointer_traits
    : public __member_pointer_traits_imp<typename remove_cv<_MP>::type,
                    is_member_function_pointer<_MP>::value,
                    is_member_object_pointer<_MP>::value>
{



};



template <class _Callable> class result_of;
# 2320 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
namespace __is_construct
{
struct __nat {};
}



template <class _Tp, class ..._Args>
struct __attribute__ ((__type_visibility__("default"))) is_constructible
    : public integral_constant<bool, __is_constructible(_Tp, _Args...)>
    {};
# 2631 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_default_constructible
    : public is_constructible<_Tp>
    {};



template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_copy_constructible
    : public is_constructible<_Tp,
                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};



template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_move_constructible

    : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>



    {};







template <class _Tp, class... _Args>
struct __attribute__ ((__type_visibility__("default"))) is_trivially_constructible
    : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
{
};
# 2783 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_default_constructible
    : public is_trivially_constructible<_Tp>
    {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_copy_constructible
    : public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
    {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_move_constructible

    : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>



    {};





template <class _Tp, class _Arg>
struct is_trivially_assignable
    : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
{
};
# 2843 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_copy_assignable
    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_move_assignable
    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,

                                     typename add_rvalue_reference<_Tp>::type>



    {};





template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_destructible
    : public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
# 2891 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;

template <class _Tp, class... _Args>
struct __libcpp_is_nothrow_constructible<true, _Tp, _Args...>
    : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
{
};

template <class _Tp, class... _Args>
struct __libcpp_is_nothrow_constructible<false, _Tp, _Args...>
    : public false_type
{
};

template <class _Tp, class... _Args>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_constructible
    : __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, _Tp, _Args...>
{
};

template <class _Tp, size_t _Ns>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_constructible<_Tp[_Ns]>
    : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, _Tp>
{
};
# 3029 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_nothrow_default_constructible
    : public is_nothrow_constructible<_Tp>
    {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_nothrow_copy_constructible
    : public is_nothrow_constructible<_Tp,
                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_nothrow_move_constructible

    : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>



    {};





template <bool, class _Tp, class _Arg> struct __libcpp_is_nothrow_assignable;

template <class _Tp, class _Arg>
struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg>
    : public false_type
{
};

template <class _Tp, class _Arg>
struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg>
    : public integral_constant<bool, noexcept(std::__1::declval<_Tp>() = std::__1::declval<_Arg>()) >
{
};

template <class _Tp, class _Arg>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_assignable
    : public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
{
};
# 3119 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_nothrow_copy_assignable
    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_nothrow_move_assignable
    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,

                                     typename add_rvalue_reference<_Tp>::type>



    {};





template <bool, class _Tp> struct __libcpp_is_nothrow_destructible;

template <class _Tp>
struct __libcpp_is_nothrow_destructible<false, _Tp>
    : public false_type
{
};

template <class _Tp>
struct __libcpp_is_nothrow_destructible<true, _Tp>
    : public integral_constant<bool, noexcept(std::__1::declval<_Tp>().~_Tp()) >
{
};

template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_destructible
    : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
{
};

template <class _Tp, size_t _Ns>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp[_Ns]>
    : public is_nothrow_destructible<_Tp>
{
};

template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp&>
    : public true_type
{
};



template <class _Tp>
struct __attribute__ ((__type_visibility__("default"))) is_nothrow_destructible<_Tp&&>
    : public true_type
{
};
# 3195 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_pod
    : public integral_constant<bool, __is_pod(_Tp)> {};
# 3210 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_literal_type

    : public integral_constant<bool, __is_literal(_Tp)>




    {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_standard_layout

    : public integral_constant<bool, __is_standard_layout(_Tp)>



    {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivially_copyable

    : public integral_constant<bool, __is_trivially_copyable(_Tp)>



    {};



template <class _Tp> struct __attribute__ ((__type_visibility__("default"))) is_trivial

    : public integral_constant<bool, __is_trivial(_Tp)>




    {};





template <class ..._Tp> struct __check_complete;

template <>
struct __check_complete<>
{
};

template <class _Hp, class _T0, class ..._Tp>
struct __check_complete<_Hp, _T0, _Tp...>
    : private __check_complete<_Hp>,
      private __check_complete<_T0, _Tp...>
{
};

template <class _Hp>
struct __check_complete<_Hp, _Hp>
    : private __check_complete<_Hp>
{
};

template <class _Tp>
struct __check_complete<_Tp>
{
    static_assert(sizeof(_Tp) > 0, "Type must be complete.");
};

template <class _Tp>
struct __check_complete<_Tp&>
    : private __check_complete<_Tp>
{
};

template <class _Tp>
struct __check_complete<_Tp&&>
    : private __check_complete<_Tp>
{
};

template <class _Rp, class ..._Param>
struct __check_complete<_Rp (*)(_Param...)>
    : private __check_complete<_Rp>
{
};

template <class ..._Param>
struct __check_complete<void (*)(_Param...)>
{
};

template <class _Rp, class ..._Param>
struct __check_complete<_Rp (_Param...)>
    : private __check_complete<_Rp>
{
};

template <class ..._Param>
struct __check_complete<void (_Param...)>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...)>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) const>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) volatile>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) const volatile>
    : private __check_complete<_Class>
{
};



template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) &>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) const&>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) volatile&>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) &&>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) const&&>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) volatile&&>
    : private __check_complete<_Class>
{
};

template <class _Rp, class _Class, class ..._Param>
struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&&>
    : private __check_complete<_Class>
{
};



template <class _Rp, class _Class>
struct __check_complete<_Rp _Class::*>
    : private __check_complete<_Class>
{
};





template <class ..._Args>
auto
__invoke(__any, _Args&& ...__args)
    -> __nat;



template <class _Fp, class _A0, class ..._Args,
            class = typename enable_if
            <
                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
                is_base_of<typename remove_reference<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType>::type,
                           typename remove_reference<_A0>::type>::value
            >::type
         >
__attribute__ ((__visibility__("hidden"), __always_inline__))
auto
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
    -> decltype((std::__1::forward<_A0>(__a0).*__f)(std::__1::forward<_Args>(__args)...));

template <class _Fp, class _A0, class ..._Args,
            class = typename enable_if
            <
                is_member_function_pointer<typename remove_reference<_Fp>::type>::value &&
                !is_base_of<typename remove_reference<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType>::type,
                           typename remove_reference<_A0>::type>::value
            >::type
         >
__attribute__ ((__visibility__("hidden"), __always_inline__))
auto
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
    -> decltype(((*std::__1::forward<_A0>(__a0)).*__f)(std::__1::forward<_Args>(__args)...));



template <class _Fp, class _A0,
            class = typename enable_if
            <
                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
                is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
                           typename remove_reference<_A0>::type>::value
            >::type
         >
__attribute__ ((__visibility__("hidden"), __always_inline__))
auto
__invoke(_Fp&& __f, _A0&& __a0)
    -> decltype(std::__1::forward<_A0>(__a0).*__f);

template <class _Fp, class _A0,
            class = typename enable_if
            <
                is_member_object_pointer<typename remove_reference<_Fp>::type>::value &&
                !is_base_of<typename __member_pointer_traits<typename remove_reference<_Fp>::type>::_ClassType,
                           typename remove_reference<_A0>::type>::value
            >::type
         >
__attribute__ ((__visibility__("hidden"), __always_inline__))
auto
__invoke(_Fp&& __f, _A0&& __a0)
    -> decltype((*std::__1::forward<_A0>(__a0)).*__f);



template <class _Fp, class ..._Args>
__attribute__ ((__visibility__("hidden"), __always_inline__))
auto
__invoke(_Fp&& __f, _Args&& ...__args)
    -> decltype(std::__1::forward<_Fp>(__f)(std::__1::forward<_Args>(__args)...));



template <class _Fp, class ..._Args>
struct __invokable_imp
    : private __check_complete<_Fp>
{
    typedef decltype(
            __invoke(std::__1::declval<_Fp>(), std::__1::declval<_Args>()...)
                    ) type;
    static const bool value = !is_same<type, __nat>::value;
};

template <class _Fp, class ..._Args>
struct __invokable
    : public integral_constant<bool,
          __invokable_imp<_Fp, _Args...>::value>
{
};



template <bool _Invokable, class _Fp, class ..._Args>
struct __invoke_of_imp
{
};

template <class _Fp, class ..._Args>
struct __invoke_of_imp<true, _Fp, _Args...>
{
    typedef typename __invokable_imp<_Fp, _Args...>::type type;
};

template <class _Fp, class ..._Args>
struct __invoke_of
    : public __invoke_of_imp<__invokable<_Fp, _Args...>::value, _Fp, _Args...>
{
};

template <class _Fp, class ..._Args>
class __attribute__ ((__type_visibility__("default"))) result_of<_Fp(_Args...)>
    : public __invoke_of<_Fp, _Args...>
{
};







template <class _Tp>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))

typename enable_if
<
    is_move_constructible<_Tp>::value &&
    is_move_assignable<_Tp>::value
>::type



swap(_Tp& __x, _Tp& __y) noexcept(is_nothrow_move_constructible<_Tp>::value && is_nothrow_move_assignable<_Tp>::value)

{
    _Tp __t(std::__1::move(__x));
    __x = std::__1::move(__y);
    __y = std::__1::move(__t);
}

template <class _ForwardIterator1, class _ForwardIterator2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)

               noexcept(noexcept(swap(*std::__1::declval<_ForwardIterator1>(), *std::__1::declval<_ForwardIterator2>())))

{
    swap(*__a, *__b);
}



namespace __detail
{

using std::__1::swap;
__nat swap(__any, __any);

template <class _Tp>
struct __swappable
{
    typedef decltype(swap(std::__1::declval<_Tp&>(), std::__1::declval<_Tp&>())) type;
    static const bool value = !is_same<type, __nat>::value;
};

}

template <class _Tp>
struct __is_swappable
    : public integral_constant<bool, __detail::__swappable<_Tp>::value>
{
};



template <bool, class _Tp>
struct __is_nothrow_swappable_imp
    : public integral_constant<bool, noexcept(swap(std::__1::declval<_Tp&>(),
                                                   std::__1::declval<_Tp&>()))>
{
};

template <class _Tp>
struct __is_nothrow_swappable_imp<false, _Tp>
    : public false_type
{
};

template <class _Tp>
struct __is_nothrow_swappable
    : public __is_nothrow_swappable_imp<__is_swappable<_Tp>::value, _Tp>
{
};
# 3605 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
struct underlying_type
{
    typedef __underlying_type(_Tp) type;
};
# 3629 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/type_traits" 3
template <class _Tp>
struct __has_operator_addressof_imp
{
    template <class>
        static auto __test(__any) -> false_type;
    template <class _Up>
        static auto __test(_Up* __u)
            -> typename __select_2nd<decltype(__u->operator&()), true_type>::type;

    static const bool value = decltype(__test<_Tp>(nullptr))::value;
};

template <class _Tp>
struct __has_operator_addressof
    : public integral_constant<bool, __has_operator_addressof_imp<_Tp>::value>
{};



} }
# 82 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/exception" 2 3
# 85 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/exception" 3


namespace std
{

class __attribute__ ((__visibility__("default"))) exception
{
public:
    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception() noexcept {}
    virtual ~exception() noexcept;
    virtual const char* what() const noexcept;
};

class __attribute__ ((__visibility__("default"))) bad_exception
    : public exception
{
public:
    __attribute__ ((__visibility__("hidden"), __always_inline__)) bad_exception() noexcept {}
    virtual ~bad_exception() noexcept;
    virtual const char* what() const noexcept;
};

typedef void (*unexpected_handler)();
__attribute__ ((__visibility__("default"))) unexpected_handler set_unexpected(unexpected_handler) noexcept;
__attribute__ ((__visibility__("default"))) unexpected_handler get_unexpected() noexcept;
[[noreturn]] __attribute__ ((__visibility__("default"))) void unexpected();

typedef void (*terminate_handler)();
__attribute__ ((__visibility__("default"))) terminate_handler set_terminate(terminate_handler) noexcept;
__attribute__ ((__visibility__("default"))) terminate_handler get_terminate() noexcept;
[[noreturn]] __attribute__ ((__visibility__("default"))) void terminate() noexcept;

__attribute__ ((__visibility__("default"))) bool uncaught_exception() noexcept;

class __attribute__ ((__type_visibility__("default"))) exception_ptr;

__attribute__ ((__visibility__("default"))) exception_ptr current_exception() noexcept;
[[noreturn]] __attribute__ ((__visibility__("default"))) void rethrow_exception(exception_ptr);

class __attribute__ ((__type_visibility__("default"))) exception_ptr
{
    void* __ptr_;
public:
    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception_ptr() noexcept : __ptr_() {}
    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception_ptr(nullptr_t) noexcept : __ptr_() {}
    exception_ptr(const exception_ptr&) noexcept;
    exception_ptr& operator=(const exception_ptr&) noexcept;
    ~exception_ptr() noexcept;

    __attribute__ ((__visibility__("hidden"), __always_inline__))
    explicit
        operator bool() const noexcept {return __ptr_ != nullptr;}

    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
    bool operator==(const exception_ptr& __x, const exception_ptr& __y) noexcept
        {return __x.__ptr_ == __y.__ptr_;}
    friend __attribute__ ((__visibility__("hidden"), __always_inline__))
    bool operator!=(const exception_ptr& __x, const exception_ptr& __y) noexcept
        {return !(__x == __y);}

    friend __attribute__ ((__visibility__("default"))) exception_ptr current_exception() noexcept;
    friend __attribute__ ((__visibility__("default"))) void rethrow_exception(exception_ptr);
};

template<class _Ep>
exception_ptr
make_exception_ptr(_Ep __e) noexcept
{

    try
    {
        throw __e;
    }
    catch (...)
    {
        return current_exception();
    }

}



class __attribute__ ((__visibility__("default"))) nested_exception
{
    exception_ptr __ptr_;
public:
    nested_exception() noexcept;


    virtual ~nested_exception() noexcept;


    [[noreturn]] void rethrow_nested() const;
    __attribute__ ((__visibility__("hidden"), __always_inline__)) exception_ptr nested_ptr() const noexcept {return __ptr_;}
};

template <class _Tp>
struct __nested
    : public _Tp,
      public nested_exception
{
    __attribute__ ((__visibility__("hidden"), __always_inline__)) explicit __nested(const _Tp& __t) : _Tp(__t) {}
};

template <class _Tp>
[[noreturn]]
void

throw_with_nested(_Tp&& __t, typename enable_if<
                  is_class<typename remove_reference<_Tp>::type>::value &&
                  !is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
                                    >::type* = 0)





{

    throw __nested<typename remove_reference<_Tp>::type>(std::__1::forward<_Tp>(__t));

}

template <class _Tp>
[[noreturn]]
void

throw_with_nested(_Tp&& __t, typename enable_if<
                  !is_class<typename remove_reference<_Tp>::type>::value ||
                  is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
                                    >::type* = 0)





{

    throw std::__1::forward<_Tp>(__t);

}

template <class _Ep>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
void
rethrow_if_nested(const _Ep& __e, typename enable_if<
                                   is_polymorphic<_Ep>::value
                                                   >::type* = 0)
{
    const nested_exception* __nep = dynamic_cast<const nested_exception*>(&__e);
    if (__nep)
        __nep->rethrow_nested();
}

template <class _Ep>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
void
rethrow_if_nested(const _Ep&, typename enable_if<
                                   !is_polymorphic<_Ep>::value
                                                   >::type* = 0)
{
}

}
# 69 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/new" 2 3
# 73 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/new" 3


namespace std
{

class __attribute__ ((__visibility__("default"))) bad_alloc
    : public exception
{
public:
    bad_alloc() noexcept;
    virtual ~bad_alloc() noexcept;
    virtual const char* what() const noexcept;
};

class __attribute__ ((__visibility__("default"))) bad_array_new_length
    : public bad_alloc
{
public:
    bad_array_new_length() noexcept;
    virtual ~bad_array_new_length() noexcept;
    virtual const char* what() const noexcept;
};
# 111 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/new" 3
__attribute__ ((__visibility__("default"))) void __throw_bad_alloc();

struct __attribute__ ((__type_visibility__("default"))) nothrow_t {};
extern __attribute__ ((__visibility__("default"))) const nothrow_t nothrow;
typedef void (*new_handler)();
__attribute__ ((__visibility__("default"))) new_handler set_new_handler(new_handler) noexcept;
__attribute__ ((__visibility__("default"))) new_handler get_new_handler() noexcept;

}







__attribute__ ((__visibility__("default"))) void* operator new(std::size_t __sz)



;
__attribute__ ((__visibility__("default"))) void* operator new(std::size_t __sz, const std::nothrow_t&) noexcept __attribute__((__malloc__));
__attribute__ ((__visibility__("default"))) void operator delete(void* __p) noexcept;
__attribute__ ((__visibility__("default"))) void operator delete(void* __p, const std::nothrow_t&) noexcept;

__attribute__ ((__visibility__("default"))) void* operator new[](std::size_t __sz)



;
__attribute__ ((__visibility__("default"))) void* operator new[](std::size_t __sz, const std::nothrow_t&) noexcept __attribute__((__malloc__));
__attribute__ ((__visibility__("default"))) void operator delete[](void* __p) noexcept;
__attribute__ ((__visibility__("default"))) void operator delete[](void* __p, const std::nothrow_t&) noexcept;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void* operator new (std::size_t, void* __p) noexcept {return __p;}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void* operator new[](std::size_t, void* __p) noexcept {return __p;}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator delete (void*, void*) noexcept {}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void operator delete[](void*, void*) noexcept {}

namespace std {inline namespace __1 {

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void *__allocate(size_t __size) {



  return __builtin_operator_new(__size);

}

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) void __deallocate(void *__ptr) {



  __builtin_operator_delete(__ptr);

}

} }
# 88 "/usr/local/cuda/include/common_functions.h" 2
# 101 "/usr/local/cuda/include/common_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t, void*) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t, void*) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*, void*) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*, void*) throw();






# 1 "/usr/include/stdio.h" 1 3 4
# 71 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_va_list.h" 1 3 4
# 31 "/usr/include/sys/_types/_va_list.h" 3 4
typedef __darwin_va_list va_list;
# 72 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 73 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/sys/_types/_null.h" 1 3 4
# 74 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/sys/stdio.h" 1 3 4
# 37 "/usr/include/sys/stdio.h" 3 4
extern "C" {

int renameat(int, const char *, int, const char *) __attribute__((availability(macosx,introduced=10.10)));

}
# 76 "/usr/include/stdio.h" 2 3 4

typedef __darwin_off_t fpos_t;
# 88 "/usr/include/stdio.h" 3 4
struct __sbuf {
 unsigned char *_base;
 int _size;
};


struct __sFILEX;
# 122 "/usr/include/stdio.h" 3 4
typedef struct __sFILE {
 unsigned char *_p;
 int _r;
 int _w;
 short _flags;
 short _file;
 struct __sbuf _bf;
 int _lbfsize;


 void *_cookie;
 int (*_close)(void *);
 int (*_read) (void *, char *, int);
 fpos_t (*_seek) (void *, fpos_t, int);
 int (*_write)(void *, const char *, int);


 struct __sbuf _ub;
 struct __sFILEX *_extra;
 int _ur;


 unsigned char _ubuf[3];
 unsigned char _nbuf[1];


 struct __sbuf _lb;


 int _blksize;
 fpos_t _offset;
} FILE;

extern "C" {
extern FILE *__stdinp;
extern FILE *__stdoutp;
extern FILE *__stderrp;
}
# 230 "/usr/include/stdio.h" 3 4
extern "C" {
void clearerr(FILE *);
int fclose(FILE *);
int feof(FILE *);
int ferror(FILE *);
int fflush(FILE *);
int fgetc(FILE *);
int fgetpos(FILE * , fpos_t *);
char *fgets(char * , int, FILE *);



FILE *fopen(const char * , const char * ) __asm("_" "fopen" );

int fprintf(FILE * , const char * , ...) __attribute__((__format__ (__printf__, 2, 3)));
int fputc(int, FILE *);
int fputs(const char * , FILE * ) __asm("_" "fputs" );
size_t fread(void * , size_t, size_t, FILE * );
FILE *freopen(const char * , const char * ,
                 FILE * ) __asm("_" "freopen" );
int fscanf(FILE * , const char * , ...) __attribute__((__format__ (__scanf__, 2, 3)));
int fseek(FILE *, long, int);
int fsetpos(FILE *, const fpos_t *);
long ftell(FILE *);
size_t fwrite(const void * , size_t, size_t, FILE * ) __asm("_" "fwrite" );
int getc(FILE *);
int getchar(void);
char *gets(char *);
void perror(const char *);
int printf(const char * , ...) __attribute__((__format__ (__printf__, 1, 2)));
int putc(int, FILE *);
int putchar(int);
int puts(const char *);
int remove(const char *);
int rename (const char *, const char *);
void rewind(FILE *);
int scanf(const char * , ...) __attribute__((__format__ (__scanf__, 1, 2)));
void setbuf(FILE * , char * );
int setvbuf(FILE * , char * , int, size_t);
int sprintf(char * , const char * , ...) __attribute__((__format__ (__printf__, 2, 3)));
int sscanf(const char * , const char * , ...) __attribute__((__format__ (__scanf__, 2, 3)));
FILE *tmpfile(void);


__attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tmpnam(3), it is highly recommended that you use mkstemp(3) instead.")))

char *tmpnam(char *);
int ungetc(int, FILE *);
int vfprintf(FILE * , const char * , va_list) __attribute__((__format__ (__printf__, 2, 0)));
int vprintf(const char * , va_list) __attribute__((__format__ (__printf__, 1, 0)));
int vsprintf(char * , const char * , va_list) __attribute__((__format__ (__printf__, 2, 0)));
}
# 292 "/usr/include/stdio.h" 3 4
extern "C" {



char *ctermid(char *);





FILE *fdopen(int, const char *) __asm("_" "fdopen" );

int fileno(FILE *);
}
# 314 "/usr/include/stdio.h" 3 4
extern "C" {
int pclose(FILE *);



FILE *popen(const char *, const char *) __asm("_" "popen" );

}
# 336 "/usr/include/stdio.h" 3 4
extern "C" {
int __srget(FILE *);
int __svfscanf(FILE *, const char *, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
int __swbuf(int, FILE *);
}







inline __attribute__ ((__always_inline__)) int __sputc(int _c, FILE *_p) {
 if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
  return (*_p->_p++ = _c);
 else
  return (__swbuf(_c, _p));
}
# 373 "/usr/include/stdio.h" 3 4
extern "C" {
void flockfile(FILE *);
int ftrylockfile(FILE *);
void funlockfile(FILE *);
int getc_unlocked(FILE *);
int getchar_unlocked(void);
int putc_unlocked(int, FILE *);
int putchar_unlocked(int);



int getw(FILE *);
int putw(int, FILE *);



__attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.")))

char *tempnam(const char *, const char *) __asm("_" "tempnam" );
}
# 411 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/sys/_types/_off_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_off_t.h" 3 4
typedef __darwin_off_t off_t;
# 412 "/usr/include/stdio.h" 2 3 4

extern "C" {
int fseeko(FILE *, off_t, int);
off_t ftello(FILE *);
}



extern "C" {
int snprintf(char * , size_t, const char * , ...) __attribute__((__format__ (__printf__, 3, 4)));
int vfscanf(FILE * , const char * , va_list) __attribute__((__format__ (__scanf__, 2, 0)));
int vscanf(const char * , va_list) __attribute__((__format__ (__scanf__, 1, 0)));
int vsnprintf(char * , size_t, const char * , va_list) __attribute__((__format__ (__printf__, 3, 0)));
int vsscanf(const char * , const char * , va_list) __attribute__((__format__ (__scanf__, 2, 0)));
}
# 438 "/usr/include/stdio.h" 3 4
extern "C" {
int dprintf(int, const char * , ...) __attribute__((__format__ (__printf__, 2, 3))) __attribute__((availability(macosx,introduced=10.7)));
int vdprintf(int, const char * , va_list) __attribute__((__format__ (__printf__, 2, 0))) __attribute__((availability(macosx,introduced=10.7)));
ssize_t getdelim(char ** , size_t * , int, FILE * ) __attribute__((availability(macosx,introduced=10.7)));
ssize_t getline(char ** , size_t * , FILE * ) __attribute__((availability(macosx,introduced=10.7)));
}







extern "C" {
extern const int sys_nerr;
extern const char *const sys_errlist[];

int asprintf(char ** , const char * , ...) __attribute__((__format__ (__printf__, 2, 3)));
char *ctermid_r(char *);
char *fgetln(FILE *, size_t *);
const char *fmtcheck(const char *, const char *);
int fpurge(FILE *);
void setbuffer(FILE *, char *, int);
int setlinebuf(FILE *);
int vasprintf(char ** , const char * , va_list) __attribute__((__format__ (__printf__, 2, 0)));
FILE *zopen(const char *, const char *, int);





FILE *funopen(const void *,
                 int (*)(void *, char *, int),
                 int (*)(void *, const char *, int),
                 fpos_t (*)(void *, fpos_t, int),
                 int (*)(void *));
}
# 111 "/usr/local/cuda/include/common_functions.h" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 65 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/sys/wait.h" 1 3 4
# 79 "/usr/include/sys/wait.h" 3 4
typedef enum {
 P_ALL,
 P_PID,
 P_PGID
} idtype_t;






# 1 "/usr/include/sys/_types/_pid_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_pid_t.h" 3 4
typedef __darwin_pid_t pid_t;
# 90 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/_types/_id_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_id_t.h" 3 4
typedef __darwin_id_t id_t;
# 91 "/usr/include/sys/wait.h" 2 3 4
# 109 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/sys/signal.h" 1 3 4
# 73 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/sys/appleapiopts.h" 1 3 4
# 74 "/usr/include/sys/signal.h" 2 3 4







# 1 "/usr/include/machine/signal.h" 1 3 4
# 32 "/usr/include/machine/signal.h" 3 4
# 1 "/usr/include/i386/signal.h" 1 3 4
# 39 "/usr/include/i386/signal.h" 3 4
typedef int sig_atomic_t;
# 33 "/usr/include/machine/signal.h" 2 3 4
# 82 "/usr/include/sys/signal.h" 2 3 4
# 145 "/usr/include/sys/signal.h" 3 4
# 1 "/usr/include/machine/_mcontext.h" 1 3 4
# 29 "/usr/include/machine/_mcontext.h" 3 4
# 1 "/usr/include/i386/_mcontext.h" 1 3 4
# 33 "/usr/include/i386/_mcontext.h" 3 4
# 1 "/usr/include/mach/i386/_structs.h" 1 3 4
# 43 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_thread_state
{
    unsigned int __eax;
    unsigned int __ebx;
    unsigned int __ecx;
    unsigned int __edx;
    unsigned int __edi;
    unsigned int __esi;
    unsigned int __ebp;
    unsigned int __esp;
    unsigned int __ss;
    unsigned int __eflags;
    unsigned int __eip;
    unsigned int __cs;
    unsigned int __ds;
    unsigned int __es;
    unsigned int __fs;
    unsigned int __gs;
};
# 89 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_control
{
    unsigned short __invalid :1,
        __denorm :1,
    __zdiv :1,
    __ovrfl :1,
    __undfl :1,
    __precis :1,
      :2,
    __pc :2,





    __rc :2,






             :1,
      :3;
};
typedef struct __darwin_fp_control __darwin_fp_control_t;
# 147 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_fp_status
{
    unsigned short __invalid :1,
        __denorm :1,
    __zdiv :1,
    __ovrfl :1,
    __undfl :1,
    __precis :1,
    __stkflt :1,
    __errsumm :1,
    __c0 :1,
    __c1 :1,
    __c2 :1,
    __tos :3,
    __c3 :1,
    __busy :1;
};
typedef struct __darwin_fp_status __darwin_fp_status_t;
# 191 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_mmst_reg
{
 char __mmst_reg[10];
 char __mmst_rsrv[6];
};
# 210 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_xmm_reg
{
 char __xmm_reg[16];
};
# 232 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_float_state
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;
 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;
 __uint16_t __fpu_rsrv2;
 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;
 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 char __fpu_rsrv4[14*16];
 int __fpu_reserved1;
};


struct __darwin_i386_avx_state
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;
 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;
 __uint16_t __fpu_rsrv2;
 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;
 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 char __fpu_rsrv4[14*16];
 int __fpu_reserved1;
 char __avx_reserved1[64];
 struct __darwin_xmm_reg __fpu_ymmh0;
 struct __darwin_xmm_reg __fpu_ymmh1;
 struct __darwin_xmm_reg __fpu_ymmh2;
 struct __darwin_xmm_reg __fpu_ymmh3;
 struct __darwin_xmm_reg __fpu_ymmh4;
 struct __darwin_xmm_reg __fpu_ymmh5;
 struct __darwin_xmm_reg __fpu_ymmh6;
 struct __darwin_xmm_reg __fpu_ymmh7;
};
# 402 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_i386_exception_state
{
 __uint16_t __trapno;
 __uint16_t __cpu;
 __uint32_t __err;
 __uint32_t __faultvaddr;
};
# 422 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state32
{
 unsigned int __dr0;
 unsigned int __dr1;
 unsigned int __dr2;
 unsigned int __dr3;
 unsigned int __dr4;
 unsigned int __dr5;
 unsigned int __dr6;
 unsigned int __dr7;
};
# 454 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_thread_state64
{
 __uint64_t __rax;
 __uint64_t __rbx;
 __uint64_t __rcx;
 __uint64_t __rdx;
 __uint64_t __rdi;
 __uint64_t __rsi;
 __uint64_t __rbp;
 __uint64_t __rsp;
 __uint64_t __r8;
 __uint64_t __r9;
 __uint64_t __r10;
 __uint64_t __r11;
 __uint64_t __r12;
 __uint64_t __r13;
 __uint64_t __r14;
 __uint64_t __r15;
 __uint64_t __rip;
 __uint64_t __rflags;
 __uint64_t __cs;
 __uint64_t __fs;
 __uint64_t __gs;
};
# 509 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_float_state64
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;


 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;

 __uint16_t __fpu_rsrv2;


 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;

 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 struct __darwin_xmm_reg __fpu_xmm8;
 struct __darwin_xmm_reg __fpu_xmm9;
 struct __darwin_xmm_reg __fpu_xmm10;
 struct __darwin_xmm_reg __fpu_xmm11;
 struct __darwin_xmm_reg __fpu_xmm12;
 struct __darwin_xmm_reg __fpu_xmm13;
 struct __darwin_xmm_reg __fpu_xmm14;
 struct __darwin_xmm_reg __fpu_xmm15;
 char __fpu_rsrv4[6*16];
 int __fpu_reserved1;
};


struct __darwin_x86_avx_state64
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;


 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;

 __uint16_t __fpu_rsrv2;


 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;

 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 struct __darwin_xmm_reg __fpu_xmm8;
 struct __darwin_xmm_reg __fpu_xmm9;
 struct __darwin_xmm_reg __fpu_xmm10;
 struct __darwin_xmm_reg __fpu_xmm11;
 struct __darwin_xmm_reg __fpu_xmm12;
 struct __darwin_xmm_reg __fpu_xmm13;
 struct __darwin_xmm_reg __fpu_xmm14;
 struct __darwin_xmm_reg __fpu_xmm15;
 char __fpu_rsrv4[6*16];
 int __fpu_reserved1;
 char __avx_reserved1[64];
 struct __darwin_xmm_reg __fpu_ymmh0;
 struct __darwin_xmm_reg __fpu_ymmh1;
 struct __darwin_xmm_reg __fpu_ymmh2;
 struct __darwin_xmm_reg __fpu_ymmh3;
 struct __darwin_xmm_reg __fpu_ymmh4;
 struct __darwin_xmm_reg __fpu_ymmh5;
 struct __darwin_xmm_reg __fpu_ymmh6;
 struct __darwin_xmm_reg __fpu_ymmh7;
 struct __darwin_xmm_reg __fpu_ymmh8;
 struct __darwin_xmm_reg __fpu_ymmh9;
 struct __darwin_xmm_reg __fpu_ymmh10;
 struct __darwin_xmm_reg __fpu_ymmh11;
 struct __darwin_xmm_reg __fpu_ymmh12;
 struct __darwin_xmm_reg __fpu_ymmh13;
 struct __darwin_xmm_reg __fpu_ymmh14;
 struct __darwin_xmm_reg __fpu_ymmh15;
};
# 751 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_exception_state64
{
    __uint16_t __trapno;
    __uint16_t __cpu;
    __uint32_t __err;
    __uint64_t __faultvaddr;
};
# 771 "/usr/include/mach/i386/_structs.h" 3 4
struct __darwin_x86_debug_state64
{
 __uint64_t __dr0;
 __uint64_t __dr1;
 __uint64_t __dr2;
 __uint64_t __dr3;
 __uint64_t __dr4;
 __uint64_t __dr5;
 __uint64_t __dr6;
 __uint64_t __dr7;
};
# 34 "/usr/include/i386/_mcontext.h" 2 3 4




struct __darwin_mcontext32
{
 struct __darwin_i386_exception_state __es;
 struct __darwin_i386_thread_state __ss;
 struct __darwin_i386_float_state __fs;
};


struct __darwin_mcontext_avx32
{
 struct __darwin_i386_exception_state __es;
 struct __darwin_i386_thread_state __ss;
 struct __darwin_i386_avx_state __fs;
};
# 76 "/usr/include/i386/_mcontext.h" 3 4
struct __darwin_mcontext64
{
 struct __darwin_x86_exception_state64 __es;
 struct __darwin_x86_thread_state64 __ss;
 struct __darwin_x86_float_state64 __fs;
};


struct __darwin_mcontext_avx64
{
 struct __darwin_x86_exception_state64 __es;
 struct __darwin_x86_thread_state64 __ss;
 struct __darwin_x86_avx_state64 __fs;
};
# 115 "/usr/include/i386/_mcontext.h" 3 4
typedef struct __darwin_mcontext64 *mcontext_t;
# 30 "/usr/include/machine/_mcontext.h" 2 3 4
# 146 "/usr/include/sys/signal.h" 2 3 4

# 1 "/usr/include/sys/_pthread/_pthread_attr_t.h" 1 3 4
# 30 "/usr/include/sys/_pthread/_pthread_attr_t.h" 3 4
typedef __darwin_pthread_attr_t pthread_attr_t;
# 148 "/usr/include/sys/signal.h" 2 3 4

# 1 "/usr/include/sys/_types/_sigaltstack.h" 1 3 4
# 36 "/usr/include/sys/_types/_sigaltstack.h" 3 4
struct __darwin_sigaltstack
{
 void *ss_sp;
 __darwin_size_t ss_size;
 int ss_flags;
};
typedef struct __darwin_sigaltstack stack_t;
# 150 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_ucontext.h" 1 3 4
# 34 "/usr/include/sys/_types/_ucontext.h" 3 4
struct __darwin_ucontext
{
 int uc_onstack;
 __darwin_sigset_t uc_sigmask;
 struct __darwin_sigaltstack uc_stack;
 struct __darwin_ucontext *uc_link;
 __darwin_size_t uc_mcsize;
 struct __darwin_mcontext64 *uc_mcontext;



};


typedef struct __darwin_ucontext ucontext_t;
# 151 "/usr/include/sys/signal.h" 2 3 4


# 1 "/usr/include/sys/_types/_sigset_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_sigset_t.h" 3 4
typedef __darwin_sigset_t sigset_t;
# 154 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 155 "/usr/include/sys/signal.h" 2 3 4
# 1 "/usr/include/sys/_types/_uid_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_uid_t.h" 3 4
typedef __darwin_uid_t uid_t;
# 156 "/usr/include/sys/signal.h" 2 3 4

union sigval {

 int sival_int;
 void *sival_ptr;
};





struct sigevent {
 int sigev_notify;
 int sigev_signo;
 union sigval sigev_value;
 void (*sigev_notify_function)(union sigval);
 pthread_attr_t *sigev_notify_attributes;
};


typedef struct __siginfo {
 int si_signo;
 int si_errno;
 int si_code;
 pid_t si_pid;
 uid_t si_uid;
 int si_status;
 void *si_addr;
 union sigval si_value;
 long si_band;
 unsigned long __pad[7];
} siginfo_t;
# 268 "/usr/include/sys/signal.h" 3 4
union __sigaction_u {
 void (*__sa_handler)(int);
 void (*__sa_sigaction)(int, struct __siginfo *,
         void *);
};


struct __sigaction {
 union __sigaction_u __sigaction_u;
 void (*sa_tramp)(void *, int, int, siginfo_t *, void *);
 sigset_t sa_mask;
 int sa_flags;
};




struct sigaction {
 union __sigaction_u __sigaction_u;
 sigset_t sa_mask;
 int sa_flags;
};
# 330 "/usr/include/sys/signal.h" 3 4
typedef void (*sig_t)(int);
# 347 "/usr/include/sys/signal.h" 3 4
struct sigvec {
 void (*sv_handler)(int);
 int sv_mask;
 int sv_flags;
};
# 366 "/usr/include/sys/signal.h" 3 4
struct sigstack {
 char *ss_sp;
 int ss_onstack;
};
# 388 "/usr/include/sys/signal.h" 3 4
extern "C" {
void (*signal(int, void (*)(int)))(int);
}
# 110 "/usr/include/sys/wait.h" 2 3 4
# 1 "/usr/include/sys/resource.h" 1 3 4
# 72 "/usr/include/sys/resource.h" 3 4
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stdint.h" 1 3 4
# 63 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 18 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/sys/_types/_int8_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int8_t.h" 3 4
typedef signed char int8_t;
# 19 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int16_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int16_t.h" 3 4
typedef short int16_t;
# 20 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int32_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int32_t.h" 3 4
typedef int int32_t;
# 21 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_int64_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_int64_t.h" 3 4
typedef long long int64_t;
# 22 "/usr/include/stdint.h" 2 3 4

# 1 "/usr/include/_types/_uint8_t.h" 1 3 4
# 31 "/usr/include/_types/_uint8_t.h" 3 4
typedef unsigned char uint8_t;
# 24 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint16_t.h" 1 3 4
# 31 "/usr/include/_types/_uint16_t.h" 3 4
typedef unsigned short uint16_t;
# 25 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint32_t.h" 1 3 4
# 31 "/usr/include/_types/_uint32_t.h" 3 4
typedef unsigned int uint32_t;
# 26 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uint64_t.h" 1 3 4
# 31 "/usr/include/_types/_uint64_t.h" 3 4
typedef unsigned long long uint64_t;
# 27 "/usr/include/stdint.h" 2 3 4


typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;



typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;






# 1 "/usr/include/sys/_types/_intptr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_intptr_t.h" 3 4
typedef __darwin_intptr_t intptr_t;
# 54 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/sys/_types/_uintptr_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_uintptr_t.h" 3 4
typedef unsigned long uintptr_t;
# 55 "/usr/include/stdint.h" 2 3 4



# 1 "/usr/include/_types/_intmax_t.h" 1 3 4
# 32 "/usr/include/_types/_intmax_t.h" 3 4
typedef long int intmax_t;
# 59 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/_types/_uintmax_t.h" 1 3 4
# 32 "/usr/include/_types/_uintmax_t.h" 3 4
typedef long unsigned int uintmax_t;
# 60 "/usr/include/stdint.h" 2 3 4
# 64 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../lib/clang/6.1.0/include/stdint.h" 2 3 4
# 73 "/usr/include/sys/resource.h" 2 3 4







# 1 "/usr/include/sys/_types/_timeval.h" 1 3 4
# 30 "/usr/include/sys/_types/_timeval.h" 3 4
struct timeval
{
 __darwin_time_t tv_sec;
 __darwin_suseconds_t tv_usec;
};
# 81 "/usr/include/sys/resource.h" 2 3 4








typedef __uint64_t rlim_t;
# 152 "/usr/include/sys/resource.h" 3 4
struct rusage {
 struct timeval ru_utime;
 struct timeval ru_stime;
# 163 "/usr/include/sys/resource.h" 3 4
 long ru_maxrss;

 long ru_ixrss;
 long ru_idrss;
 long ru_isrss;
 long ru_minflt;
 long ru_majflt;
 long ru_nswap;
 long ru_inblock;
 long ru_oublock;
 long ru_msgsnd;
 long ru_msgrcv;
 long ru_nsignals;
 long ru_nvcsw;
 long ru_nivcsw;


};
# 192 "/usr/include/sys/resource.h" 3 4
typedef void *rusage_info_t;

struct rusage_info_v0 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
};

struct rusage_info_v1 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
 uint64_t ri_child_user_time;
 uint64_t ri_child_system_time;
 uint64_t ri_child_pkg_idle_wkups;
 uint64_t ri_child_interrupt_wkups;
 uint64_t ri_child_pageins;
 uint64_t ri_child_elapsed_abstime;
};

struct rusage_info_v2 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
 uint64_t ri_child_user_time;
 uint64_t ri_child_system_time;
 uint64_t ri_child_pkg_idle_wkups;
 uint64_t ri_child_interrupt_wkups;
 uint64_t ri_child_pageins;
 uint64_t ri_child_elapsed_abstime;
 uint64_t ri_diskio_bytesread;
 uint64_t ri_diskio_byteswritten;
};

struct rusage_info_v3 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
 uint64_t ri_child_user_time;
 uint64_t ri_child_system_time;
 uint64_t ri_child_pkg_idle_wkups;
 uint64_t ri_child_interrupt_wkups;
 uint64_t ri_child_pageins;
 uint64_t ri_child_elapsed_abstime;
 uint64_t ri_diskio_bytesread;
 uint64_t ri_diskio_byteswritten;
 uint64_t ri_cpu_time_qos_default;
 uint64_t ri_cpu_time_qos_maintenance;
 uint64_t ri_cpu_time_qos_background;
 uint64_t ri_cpu_time_qos_utility;
 uint64_t ri_cpu_time_qos_legacy;
 uint64_t ri_cpu_time_qos_user_initiated;
 uint64_t ri_cpu_time_qos_user_interactive;
 uint64_t ri_billed_system_time;
 uint64_t ri_serviced_system_time;
};

typedef struct rusage_info_v3 rusage_info_current;
# 325 "/usr/include/sys/resource.h" 3 4
struct rlimit {
 rlim_t rlim_cur;
 rlim_t rlim_max;
};
# 353 "/usr/include/sys/resource.h" 3 4
struct proc_rlimit_control_wakeupmon {
 uint32_t wm_flags;
 int32_t wm_rate;
};
# 382 "/usr/include/sys/resource.h" 3 4
extern "C" {
int getpriority(int, id_t);

int getiopolicy_np(int, int) __attribute__((availability(macosx,introduced=10.5)));

int getrlimit(int, struct rlimit *) __asm("_" "getrlimit" );
int getrusage(int, struct rusage *);
int setpriority(int, id_t, int);

int setiopolicy_np(int, int, int) __attribute__((availability(macosx,introduced=10.5)));

int setrlimit(int, const struct rlimit *) __asm("_" "setrlimit" );
}
# 111 "/usr/include/sys/wait.h" 2 3 4
# 186 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/machine/endian.h" 1 3 4
# 35 "/usr/include/machine/endian.h" 3 4
# 1 "/usr/include/i386/endian.h" 1 3 4
# 99 "/usr/include/i386/endian.h" 3 4
# 1 "/usr/include/sys/_endian.h" 1 3 4
# 130 "/usr/include/sys/_endian.h" 3 4
# 1 "/usr/include/libkern/_OSByteOrder.h" 1 3 4
# 66 "/usr/include/libkern/_OSByteOrder.h" 3 4
# 1 "/usr/include/libkern/i386/_OSByteOrder.h" 1 3 4
# 44 "/usr/include/libkern/i386/_OSByteOrder.h" 3 4
static inline
__uint16_t
_OSSwapInt16(
    __uint16_t _data
)
{
    return ((__uint16_t)((_data << 8) | (_data >> 8)));
}

static inline
__uint32_t
_OSSwapInt32(
    __uint32_t _data
)
{

    return __builtin_bswap32(_data);




}


static inline
__uint64_t
_OSSwapInt64(
    __uint64_t _data
)
{
    return __builtin_bswap64(_data);
}
# 67 "/usr/include/libkern/_OSByteOrder.h" 2 3 4
# 131 "/usr/include/sys/_endian.h" 2 3 4
# 100 "/usr/include/i386/endian.h" 2 3 4
# 36 "/usr/include/machine/endian.h" 2 3 4
# 187 "/usr/include/sys/wait.h" 2 3 4







union wait {
 int w_status;



 struct {

  unsigned int w_Termsig:7,
    w_Coredump:1,
    w_Retcode:8,
    w_Filler:16;







 } w_T;





 struct {

  unsigned int w_Stopval:8,
    w_Stopsig:8,
    w_Filler:16;






 } w_S;
};
# 247 "/usr/include/sys/wait.h" 3 4
extern "C" {
pid_t wait(int *) __asm("_" "wait" );
pid_t waitpid(pid_t, int *, int) __asm("_" "waitpid" );

int waitid(idtype_t, id_t, siginfo_t *, int) __asm("_" "waitid" );


pid_t wait3(int *, int, struct rusage *);
pid_t wait4(pid_t, int *, int, struct rusage *);

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

# 1 "/usr/include/alloca.h" 1 3 4
# 29 "/usr/include/alloca.h" 3 4
# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 30 "/usr/include/alloca.h" 2 3 4

extern "C" {
void *alloca(size_t);
}
# 68 "/usr/include/stdlib.h" 2 3 4





# 1 "/usr/include/sys/_types/_size_t.h" 1 3 4
# 74 "/usr/include/stdlib.h" 2 3 4


# 1 "/usr/include/sys/_types/_ct_rune_t.h" 1 3 4
# 31 "/usr/include/sys/_types/_ct_rune_t.h" 3 4
typedef __darwin_ct_rune_t ct_rune_t;
# 77 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_rune_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_rune_t.h" 3 4
typedef __darwin_rune_t rune_t;
# 78 "/usr/include/stdlib.h" 2 3 4


# 1 "/usr/include/sys/_types/_wchar_t.h" 1 3 4
# 81 "/usr/include/stdlib.h" 2 3 4

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

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


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



# 1 "/usr/include/sys/_types/_null.h" 1 3 4
# 100 "/usr/include/stdlib.h" 2 3 4
# 117 "/usr/include/stdlib.h" 3 4
extern int __mb_cur_max;
# 127 "/usr/include/stdlib.h" 3 4
extern "C" {
void abort(void) __attribute__((noreturn));
int abs(int) __attribute__((const));
int atexit(void (*)(void));
double atof(const char *);
int atoi(const char *);
long atol(const char *);

long long
  atoll(const char *);

void *bsearch(const void *, const void *, size_t,
     size_t, int (*)(const void *, const void *));
void *calloc(size_t, size_t);
div_t div(int, int) __attribute__((const));
void exit(int) __attribute__((noreturn));
void free(void *);
char *getenv(const char *);
long labs(long) __attribute__((const));
ldiv_t ldiv(long, long) __attribute__((const));

long long
  llabs(long long);
lldiv_t lldiv(long long, long long);

void *malloc(size_t);
int mblen(const char *, size_t);
size_t mbstowcs(wchar_t * , const char * , size_t);
int mbtowc(wchar_t * , const char * , size_t);
int posix_memalign(void **, size_t, size_t) __attribute__((availability(macosx,introduced=10.6)));
void qsort(void *, size_t, size_t,
     int (*)(const void *, const void *));
int rand(void);
void *realloc(void *, size_t);
void srand(unsigned);
double strtod(const char *, char **) __asm("_" "strtod" );
float strtof(const char *, char **) __asm("_" "strtof" );
long strtol(const char *, char **, int);
long double
  strtold(const char *, char **);

long long
  strtoll(const char *, char **, int);

unsigned long
  strtoul(const char *, char **, int);

unsigned long long
  strtoull(const char *, char **, int);

int system(const char *) __asm("_" "system" ) __attribute__((availability(macosx,introduced=10.0)));
size_t wcstombs(char * , const wchar_t * , size_t);
int wctomb(char *, wchar_t);


void _Exit(int) __attribute__((noreturn));
long a64l(const char *);
double drand48(void);
char *ecvt(double, int, int *, int *);
double erand48(unsigned short[3]);
char *fcvt(double, int, int *, int *);
char *gcvt(double, int, char *);
int getsubopt(char **, char * const *, char **);
int grantpt(int);

char *initstate(unsigned, char *, size_t);



long jrand48(unsigned short[3]);
char *l64a(long);
void lcong48(unsigned short[7]);
long lrand48(void);
char *mktemp(char *);
int mkstemp(char *);
long mrand48(void);
long nrand48(unsigned short[3]);
int posix_openpt(int);
char *ptsname(int);
int putenv(char *) __asm("_" "putenv" );
long random(void);
int rand_r(unsigned *);

char *realpath(const char * , char * ) __asm("_" "realpath" "$DARWIN_EXTSN");



unsigned short
 *seed48(unsigned short[3]);
int setenv(const char *, const char *, int) __asm("_" "setenv" );

void setkey(const char *) __asm("_" "setkey" );



char *setstate(const char *);
void srand48(long);

void srandom(unsigned);



int unlockpt(int);

int unsetenv(const char *) __asm("_" "unsetenv" );







# 1 "/usr/include/machine/types.h" 1 3 4
# 35 "/usr/include/machine/types.h" 3 4
# 1 "/usr/include/i386/types.h" 1 3 4
# 81 "/usr/include/i386/types.h" 3 4
typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int u_int32_t;
typedef unsigned long long u_int64_t;


typedef int64_t register_t;
# 97 "/usr/include/i386/types.h" 3 4
typedef u_int64_t user_addr_t;
typedef u_int64_t user_size_t;
typedef int64_t user_ssize_t;
typedef int64_t user_long_t;
typedef u_int64_t user_ulong_t;
typedef int64_t user_time_t;
typedef int64_t user_off_t;







typedef u_int64_t syscall_arg_t;
# 36 "/usr/include/machine/types.h" 2 3 4
# 239 "/usr/include/stdlib.h" 2 3 4

# 1 "/usr/include/sys/_types/_dev_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_dev_t.h" 3 4
typedef __darwin_dev_t dev_t;
# 241 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/sys/_types/_mode_t.h" 1 3 4
# 30 "/usr/include/sys/_types/_mode_t.h" 3 4
typedef __darwin_mode_t mode_t;
# 242 "/usr/include/stdlib.h" 2 3 4

u_int32_t arc4random(void);
void arc4random_addrandom(unsigned char * , int );
void arc4random_buf(void * , size_t ) __attribute__((availability(macosx,introduced=10.7)));
void arc4random_stir(void);
u_int32_t
  arc4random_uniform(u_int32_t ) __attribute__((availability(macosx,introduced=10.7)));







char *cgetcap(char *, const char *, int);
int cgetclose(void);
int cgetent(char **, char **, const char *);
int cgetfirst(char **, char **);
int cgetmatch(const char *, const char *);
int cgetnext(char **, char **);
int cgetnum(char *, const char *, long *);
int cgetset(const char *);
int cgetstr(char *, const char *, char **);
int cgetustr(char *, const char *, char **);

int daemon(int, int) __asm("_" "daemon" "$1050") __attribute__((availability(macosx,introduced=10.0,deprecated=10.5)));
char *devname(dev_t, mode_t);
char *devname_r(dev_t, mode_t, char *buf, int len);
char *getbsize(int *, long *);
int getloadavg(double [], int);
const char
 *getprogname(void);

int heapsort(void *, size_t, size_t,
     int (*)(const void *, const void *));




int mergesort(void *, size_t, size_t,
     int (*)(const void *, const void *));




void psort(void *, size_t, size_t,
     int (*)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));




void psort_r(void *, size_t, size_t, void *,
     int (*)(void *, const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));




void qsort_r(void *, size_t, size_t, void *,
     int (*)(void *, const void *, const void *));
int radixsort(const unsigned char **, int, const unsigned char *,
     unsigned);
void setprogname(const char *);
int sradixsort(const unsigned char **, int, const unsigned char *,
     unsigned);
void sranddev(void);
void srandomdev(void);
void *reallocf(void *, size_t);

long long
  strtoq(const char *, char **, int);
unsigned long long
  strtouq(const char *, char **, int);

extern char *suboptarg;
void *valloc(size_t);






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





extern "C"
{
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int printf(const char*, ...);

extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int fprintf(FILE*, const char*, ...);


extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* malloc(size_t) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void free(void*) ;

}






# 1 "/usr/include/assert.h" 1 3 4
# 75 "/usr/include/assert.h" 3 4
extern "C" {
void __assert_rtn(const char *, const char *, int, const char *) __attribute__((noreturn));



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


extern "C"
{
# 146 "/usr/local/cuda/include/common_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void __assert_rtn(
  const char *, const char *, int, const char *);
# 164 "/usr/local/cuda/include/common_functions.h"
}
# 195 "/usr/local/cuda/include/common_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new(std:: size_t) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void* operator new[](std:: size_t) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete(void*) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) void operator delete[](void*) throw();
# 219 "/usr/local/cuda/include/common_functions.h"
# 1 "/usr/local/cuda/include/math_functions.h" 1
# 83 "/usr/local/cuda/include/math_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 84 "/usr/local/cuda/include/math_functions.h" 2
# 93 "/usr/local/cuda/include/math_functions.h"
extern "C"
{
# 151 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) int abs(int) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long int labs(long int) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) long long int llabs(long long int) ;
# 200 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fabs(double x) ;
# 241 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fabsf(float x) ;



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);
# 270 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fminf(float x, float y) ;
# 290 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmin(double x, double y) ;






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);
# 322 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaxf(float x, float y) ;
# 342 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmax(double, double) ;
# 386 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sin(double x) ;
# 419 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cos(double x) ;
# 438 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincos(double x, double *sptr, double *cptr) ;
# 454 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincosf(float x, float *sptr, float *cptr) ;
# 499 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tan(double x) ;
# 568 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sqrt(double x) ;
# 640 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rsqrt(double x);
# 710 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rsqrtf(float x);
# 766 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log2(double x) ;
# 791 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp2(double x) ;
# 816 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp2f(float x) ;
# 843 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp10(double x) ;
# 866 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float exp10f(float x) ;
# 912 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double expm1(double x) ;
# 957 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expm1f(float x) ;
# 1012 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log2f(float x) ;
# 1066 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log10(double x) ;
# 1137 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log(double x) ;
# 1231 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double log1p(double x) ;
# 1328 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log1pf(float x) ;
# 1403 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double floor(double x) ;
# 1442 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double exp(double x) ;
# 1473 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cosh(double x) ;
# 1503 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinh(double x) ;
# 1533 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tanh(double x) ;
# 1568 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acosh(double x) ;
# 1606 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acoshf(float x) ;
# 1622 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asinh(double x) ;
# 1638 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinhf(float x) ;
# 1692 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atanh(double x) ;
# 1746 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanhf(float x) ;
# 1805 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ldexp(double x, int exp) ;
# 1861 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ldexpf(float x, int exp) ;
# 1913 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double logb(double x) ;
# 1968 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logbf(float x) ;
# 1998 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogb(double x) ;
# 2028 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int ilogbf(float x) ;
# 2104 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbn(double x, int n) ;
# 2180 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalbnf(float x, int n) ;
# 2256 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double scalbln(double x, long int n) ;
# 2332 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float scalblnf(float x, long int n) ;
# 2410 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double frexp(double x, int *nptr) ;
# 2485 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float frexpf(float x, int *nptr) ;
# 2499 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double round(double x) ;
# 2516 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float roundf(float x) ;
# 2534 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lround(double x) ;
# 2552 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lroundf(float x) ;
# 2570 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llround(double x) ;
# 2588 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llroundf(float x) ;
# 2603 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rint(double x) ;
# 2618 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rintf(float x) ;
# 2634 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrint(double x) ;
# 2650 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long int lrintf(float x) ;
# 2666 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrint(double x) ;
# 2682 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) long long int llrintf(float x) ;
# 2735 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nearbyint(double x) ;
# 2788 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nearbyintf(float x) ;
# 2850 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double ceil(double x) ;
# 2862 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double trunc(double x) ;
# 2877 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float truncf(float x) ;
# 2903 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fdim(double x, double y) ;
# 2929 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fdimf(float x, float y) ;
# 2965 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan2(double y, double x) ;
# 2996 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double atan(double x) ;
# 3019 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double acos(double x) ;
# 3051 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double asin(double x) ;
# 3093 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double hypot(double x, double y) ;
# 3145 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rhypot(double x, double y) ;
# 3191 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float hypotf(float x, float y) ;
# 3243 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rhypotf(float x, float y) ;
# 3290 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm3d(double a, double b, double c) ;
# 3341 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rnorm3d(double a, double b, double c) ;
# 3390 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double norm4d(double a, double b, double c, double d) ;
# 3434 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float norm3df(float a, float b, float c) ;
# 3485 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rnorm3df(float a, float b, float c) ;
# 3534 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float norm4df(float a, float b, float c, float d) ;
# 3618 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cbrt(double x) ;
# 3704 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cbrtf(float x) ;
# 3759 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double rcbrt(double x);
# 3809 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float rcbrtf(float x);
# 3869 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double sinpi(double x);
# 3929 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinpif(float x);
# 3981 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cospi(double x);
# 4033 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cospif(float x);
# 4063 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospi(double x, double *sptr, double *cptr);
# 4093 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) void sincospif(float x, float *sptr, float *cptr);
# 4405 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double pow(double x, double y) ;
# 4461 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double modf(double x, double *iptr) ;
# 4520 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fmod(double x, double y) ;
# 4606 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remainder(double x, double y) ;
# 4696 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remainderf(float x, float y) ;
# 4750 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double remquo(double x, double y, int *quo) ;
# 4804 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float remquof(float x, float y, int *quo) ;
# 4845 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j0(double x) ;
# 4887 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j0f(float x) ;
# 4948 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double j1(double x) ;
# 5009 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float j1f(float x) ;
# 5052 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double jn(int n, double x) ;
# 5095 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float jnf(int n, float x) ;
# 5147 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y0(double x) ;
# 5199 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y0f(float x) ;
# 5251 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double y1(double x) ;
# 5303 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float y1f(float x) ;
# 5356 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double yn(int n, double x) ;
# 5409 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ynf(int n, float x) ;
# 5436 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i0(double x) ;
# 5462 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i0f(float x) ;
# 5489 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double cyl_bessel_i1(double x) ;
# 5515 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cyl_bessel_i1f(float x) ;
# 5598 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erf(double x) ;
# 5680 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erff(float x) ;
# 5744 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfinv(double y);
# 5801 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfinvf(float y);
# 5840 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfc(double x) ;
# 5878 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcf(float x) ;
# 6006 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double lgamma(double x) ;
# 6069 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcinv(double y);
# 6125 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcinvf(float y);
# 6183 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdfinv(double y);
# 6241 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdfinvf(float y);
# 6284 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double normcdf(double y);
# 6327 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float normcdff(float y);
# 6402 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double erfcx(double x);
# 6477 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float erfcxf(float x);
# 6611 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float lgammaf(float x) ;
# 6720 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double tgamma(double x) ;
# 6829 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tgammaf(float x) ;
# 6842 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double copysign(double x, double y) ;
# 6855 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float copysignf(float x, float y) ;
# 6892 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nextafter(double x, double y) ;
# 6929 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nextafterf(float x, float y) ;
# 6945 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double nan(const char *tagp) ;
# 6961 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float nanf(const char *tagp) ;






extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinff(float) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnanf(float) ;



extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isfinited(double) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isfinitef(float) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitd(double) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnand(double) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinfd(double) ;
# 6986 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitf(float) ;
# 7145 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) double fma(double x, double y, double z) ;
# 7303 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmaf(float x, float y, float z) ;
# 7314 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __signbitl(long double) ;

extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isfinite(long double) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isinf(long double) ;
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) int __isnan(long double) ;
# 7372 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float acosf(float x) ;
# 7412 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float asinf(float x) ;
# 7452 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atanf(float x) ;
# 7485 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float atan2f(float y, float x) ;
# 7509 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float cosf(float x) ;
# 7551 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinf(float x) ;
# 7593 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanf(float x) ;
# 7617 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float coshf(float x) ;
# 7658 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sinhf(float x) ;
# 7688 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float tanhf(float x) ;
# 7739 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float logf(float x) ;
# 7789 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float expf(float x) ;
# 7840 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float log10f(float x) ;
# 7895 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float modff(float x, float *iptr) ;
# 8203 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float powf(float x, float y) ;
# 8272 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float sqrtf(float x) ;
# 8331 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float ceilf(float x) ;
# 8403 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float floorf(float x) ;
# 8462 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((device_builtin)) float fmodf(float x, float y) ;
# 8476 "/usr/local/cuda/include/math_functions.h"
}




# 1 "/usr/include/math.h" 1 3 4
# 33 "/usr/include/math.h" 3 4
extern "C" {
# 44 "/usr/include/math.h" 3 4
    typedef float float_t;
    typedef double double_t;
# 111 "/usr/include/math.h" 3 4
extern int __math_errhandling(void);
# 144 "/usr/include/math.h" 3 4
extern int __fpclassifyf(float);
extern int __fpclassifyd(double);
extern int __fpclassifyl(long double);
# 188 "/usr/include/math.h" 3 4
inline __attribute__ ((__always_inline__)) int __inline_isfinitef(float);
inline __attribute__ ((__always_inline__)) int __inline_isfinited(double);
inline __attribute__ ((__always_inline__)) int __inline_isfinitel(long double);
inline __attribute__ ((__always_inline__)) int __inline_isinff(float);
inline __attribute__ ((__always_inline__)) int __inline_isinfd(double);
inline __attribute__ ((__always_inline__)) int __inline_isinfl(long double);
inline __attribute__ ((__always_inline__)) int __inline_isnanf(float);
inline __attribute__ ((__always_inline__)) int __inline_isnand(double);
inline __attribute__ ((__always_inline__)) int __inline_isnanl(long double);
inline __attribute__ ((__always_inline__)) int __inline_isnormalf(float);
inline __attribute__ ((__always_inline__)) int __inline_isnormald(double);
inline __attribute__ ((__always_inline__)) int __inline_isnormall(long double);
inline __attribute__ ((__always_inline__)) int __inline_signbitf(float);
inline __attribute__ ((__always_inline__)) int __inline_signbitd(double);
inline __attribute__ ((__always_inline__)) int __inline_signbitl(long double);

inline __attribute__ ((__always_inline__)) int __inline_isfinitef(float __x) {
    return __x == __x && __builtin_fabsf(__x) != __builtin_inff();
}
inline __attribute__ ((__always_inline__)) int __inline_isfinited(double __x) {
    return __x == __x && __builtin_fabs(__x) != __builtin_inf();
}
inline __attribute__ ((__always_inline__)) int __inline_isfinitel(long double __x) {
    return __x == __x && __builtin_fabsl(__x) != __builtin_infl();
}
inline __attribute__ ((__always_inline__)) int __inline_isinff(float __x) {
    return __builtin_fabsf(__x) == __builtin_inff();
}
inline __attribute__ ((__always_inline__)) int __inline_isinfd(double __x) {
    return __builtin_fabs(__x) == __builtin_inf();
}
inline __attribute__ ((__always_inline__)) int __inline_isinfl(long double __x) {
    return __builtin_fabsl(__x) == __builtin_infl();
}
inline __attribute__ ((__always_inline__)) int __inline_isnanf(float __x) {
    return __x != __x;
}
inline __attribute__ ((__always_inline__)) int __inline_isnand(double __x) {
    return __x != __x;
}
inline __attribute__ ((__always_inline__)) int __inline_isnanl(long double __x) {
    return __x != __x;
}
inline __attribute__ ((__always_inline__)) int __inline_signbitf(float __x) {
    union { float __f; unsigned int __u; } __u;
    __u.__f = __x;
    return (int)(__u.__u >> 31);
}
inline __attribute__ ((__always_inline__)) int __inline_signbitd(double __x) {
    union { double __f; unsigned long long __u; } __u;
    __u.__f = __x;
    return (int)(__u.__u >> 63);
}

inline __attribute__ ((__always_inline__)) int __inline_signbitl(long double __x) {
    union {
        long double __ld;
        struct{ unsigned long long __m; unsigned short __sexp; } __p;
    } __u;
    __u.__ld = __x;
    return (int)(__u.__p.__sexp >> 15);
}







inline __attribute__ ((__always_inline__)) int __inline_isnormalf(float __x) {
    return __inline_isfinitef(__x) && __builtin_fabsf(__x) >= 1.17549435e-38F;
}
inline __attribute__ ((__always_inline__)) int __inline_isnormald(double __x) {
    return __inline_isfinited(__x) && __builtin_fabs(__x) >= 2.2250738585072014e-308;
}
inline __attribute__ ((__always_inline__)) int __inline_isnormall(long double __x) {
    return __inline_isfinitel(__x) && __builtin_fabsl(__x) >= 3.36210314311209350626e-4932L;
}
# 322 "/usr/include/math.h" 3 4
extern float acosf(float);
extern double acos(double);
extern long double acosl(long double);

extern float asinf(float);
extern double asin(double);
extern long double asinl(long double);

extern float atanf(float);
extern double atan(double);
extern long double atanl(long double);

extern float atan2f(float, float);
extern double atan2(double, double);
extern long double atan2l(long double, long double);

extern float cosf(float);
extern double cos(double);
extern long double cosl(long double);

extern float sinf(float);
extern double sin(double);
extern long double sinl(long double);

extern float tanf(float);
extern double tan(double);
extern long double tanl(long double);

extern float acoshf(float);
extern double acosh(double);
extern long double acoshl(long double);

extern float asinhf(float);
extern double asinh(double);
extern long double asinhl(long double);

extern float atanhf(float);
extern double atanh(double);
extern long double atanhl(long double);

extern float coshf(float);
extern double cosh(double);
extern long double coshl(long double);

extern float sinhf(float);
extern double sinh(double);
extern long double sinhl(long double);

extern float tanhf(float);
extern double tanh(double);
extern long double tanhl(long double);

extern float expf(float);
extern double exp(double);
extern long double expl(long double);

extern float exp2f(float);
extern double exp2(double);
extern long double exp2l(long double);

extern float expm1f(float);
extern double expm1(double);
extern long double expm1l(long double);

extern float logf(float);
extern double log(double);
extern long double logl(long double);

extern float log10f(float);
extern double log10(double);
extern long double log10l(long double);

extern float log2f(float);
extern double log2(double);
extern long double log2l(long double);

extern float log1pf(float);
extern double log1p(double);
extern long double log1pl(long double);

extern float logbf(float);
extern double logb(double);
extern long double logbl(long double);

extern float modff(float, float *);
extern double modf(double, double *);
extern long double modfl(long double, long double *);

extern float ldexpf(float, int);
extern double ldexp(double, int);
extern long double ldexpl(long double, int);

extern float frexpf(float, int *);
extern double frexp(double, int *);
extern long double frexpl(long double, int *);

extern int ilogbf(float);
extern int ilogb(double);
extern int ilogbl(long double);

extern float scalbnf(float, int);
extern double scalbn(double, int);
extern long double scalbnl(long double, int);

extern float scalblnf(float, long int);
extern double scalbln(double, long int);
extern long double scalblnl(long double, long int);

extern float fabsf(float);
extern double fabs(double);
extern long double fabsl(long double);

extern float cbrtf(float);
extern double cbrt(double);
extern long double cbrtl(long double);

extern float hypotf(float, float);
extern double hypot(double, double);
extern long double hypotl(long double, long double);

extern float powf(float, float);
extern double pow(double, double);
extern long double powl(long double, long double);

extern float sqrtf(float);
extern double sqrt(double);
extern long double sqrtl(long double);

extern float erff(float);
extern double erf(double);
extern long double erfl(long double);

extern float erfcf(float);
extern double erfc(double);
extern long double erfcl(long double);




extern float lgammaf(float);
extern double lgamma(double);
extern long double lgammal(long double);

extern float tgammaf(float);
extern double tgamma(double);
extern long double tgammal(long double);

extern float ceilf(float);
extern double ceil(double);
extern long double ceill(long double);

extern float floorf(float);
extern double floor(double);
extern long double floorl(long double);

extern float nearbyintf(float);
extern double nearbyint(double);
extern long double nearbyintl(long double);

extern float rintf(float);
extern double rint(double);
extern long double rintl(long double);

extern long int lrintf(float);
extern long int lrint(double);
extern long int lrintl(long double);

extern float roundf(float);
extern double round(double);
extern long double roundl(long double);

extern long int lroundf(float);
extern long int lround(double);
extern long int lroundl(long double);




extern long long int llrintf(float);
extern long long int llrint(double);
extern long long int llrintl(long double);

extern long long int llroundf(float);
extern long long int llround(double);
extern long long int llroundl(long double);


extern float truncf(float);
extern double trunc(double);
extern long double truncl(long double);

extern float fmodf(float, float);
extern double fmod(double, double);
extern long double fmodl(long double, long double);

extern float remainderf(float, float);
extern double remainder(double, double);
extern long double remainderl(long double, long double);

extern float remquof(float, float, int *);
extern double remquo(double, double, int *);
extern long double remquol(long double, long double, int *);

extern float copysignf(float, float);
extern double copysign(double, double);
extern long double copysignl(long double, long double);

extern float nanf(const char *);
extern double nan(const char *);
extern long double nanl(const char *);

extern float nextafterf(float, float);
extern double nextafter(double, double);
extern long double nextafterl(long double, long double);

extern double nexttoward(double, long double);
extern float nexttowardf(float, long double);
extern long double nexttowardl(long double, long double);

extern float fdimf(float, float);
extern double fdim(double, double);
extern long double fdiml(long double, long double);

extern float fmaxf(float, float);
extern double fmax(double, double);
extern long double fmaxl(long double, long double);

extern float fminf(float, float);
extern double fmin(double, double);
extern long double fminl(long double, long double);

extern float fmaf(float, float, float);
extern double fma(double, double, double);
extern long double fmal(long double, long double, long double);
# 565 "/usr/include/math.h" 3 4
extern float __inff(void) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));
extern double __inf(void) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));
extern long double __infl(void) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));

extern float __nan(void) __attribute__((availability(macosx,introduced=10.0)));
# 597 "/usr/include/math.h" 3 4
extern float __exp10f(float) __attribute__((availability(macosx,introduced=10.9)));
extern double __exp10(double) __attribute__((availability(macosx,introduced=10.9)));





inline __attribute__ ((__always_inline__)) void __sincosf(float __x, float *__sinp, float *__cosp) __attribute__((availability(macosx,introduced=10.9)));
inline __attribute__ ((__always_inline__)) void __sincos(double __x, double *__sinp, double *__cosp) __attribute__((availability(macosx,introduced=10.9)));
# 614 "/usr/include/math.h" 3 4
extern float __cospif(float) __attribute__((availability(macosx,introduced=10.9)));
extern double __cospi(double) __attribute__((availability(macosx,introduced=10.9)));
extern float __sinpif(float) __attribute__((availability(macosx,introduced=10.9)));
extern double __sinpi(double) __attribute__((availability(macosx,introduced=10.9)));
extern float __tanpif(float) __attribute__((availability(macosx,introduced=10.9)));
extern double __tanpi(double) __attribute__((availability(macosx,introduced=10.9)));






inline __attribute__ ((__always_inline__)) void __sincospif(float __x, float *__sinp, float *__cosp) __attribute__((availability(macosx,introduced=10.9)));
inline __attribute__ ((__always_inline__)) void __sincospi(double __x, double *__sinp, double *__cosp) __attribute__((availability(macosx,introduced=10.9)));






struct __float2 { float __sinval; float __cosval; };
struct __double2 { double __sinval; double __cosval; };

extern struct __float2 __sincosf_stret(float);
extern struct __double2 __sincos_stret(double);
extern struct __float2 __sincospif_stret(float);
extern struct __double2 __sincospi_stret(double);

inline __attribute__ ((__always_inline__)) void __sincosf(float __x, float *__sinp, float *__cosp) {
    const struct __float2 __stret = __sincosf_stret(__x);
    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
}

inline __attribute__ ((__always_inline__)) void __sincos(double __x, double *__sinp, double *__cosp) {
    const struct __double2 __stret = __sincos_stret(__x);
    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
}

inline __attribute__ ((__always_inline__)) void __sincospif(float __x, float *__sinp, float *__cosp) {
    const struct __float2 __stret = __sincospif_stret(__x);
    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
}

inline __attribute__ ((__always_inline__)) void __sincospi(double __x, double *__sinp, double *__cosp) {
    const struct __double2 __stret = __sincospi_stret(__x);
    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
}






extern double j0(double) __attribute__((availability(macosx,introduced=10.0)));
extern double j1(double) __attribute__((availability(macosx,introduced=10.0)));
extern double jn(int, double) __attribute__((availability(macosx,introduced=10.0)));
extern double y0(double) __attribute__((availability(macosx,introduced=10.0)));
extern double y1(double) __attribute__((availability(macosx,introduced=10.0)));
extern double yn(int, double) __attribute__((availability(macosx,introduced=10.0)));
extern double scalb(double, double);
extern int signgam;
# 712 "/usr/include/math.h" 3 4
extern long int rinttol(double) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));

extern long int roundtol(double) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));

extern double drem(double, double) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));

extern int finite(double) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));

extern double gamma(double) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));

extern double significand(double) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)));
# 737 "/usr/include/math.h" 3 4
}
# 8481 "/usr/local/cuda/include/math_functions.h" 2



# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cmath" 1 3
# 310 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cmath" 3






template <class _A1>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_signbit(_A1 __x) noexcept
{
    return ( sizeof(__x) == sizeof(float) ? __inline_signbitf((float)(__x)) : sizeof(__x) == sizeof(double) ? __inline_signbitd((double)(__x)) : __inline_signbitl((long double)(__x)));
}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
signbit(_A1 __x) noexcept
{
    return __libcpp_signbit((typename std::__promote<_A1>::type)__x);
}







template <class _A1>
__attribute__ ((__visibility__("hidden"), __always_inline__))
int
__libcpp_fpclassify(_A1 __x) noexcept
{
    return ( sizeof(__x) == sizeof(float) ? __fpclassifyf((float)(__x)) : sizeof(__x) == sizeof(double) ? __fpclassifyd((double)(__x)) : __fpclassifyl((long double)(__x)));
}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if<std::is_arithmetic<_A1>::value, int>::type
fpclassify(_A1 __x) noexcept
{
    return __libcpp_fpclassify((typename std::__promote<_A1>::type)__x);
}







template <class _A1>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isfinite(_A1 __x) noexcept
{
    return ( sizeof(__x) == sizeof(float) ? __inline_isfinitef((float)(__x)) : sizeof(__x) == sizeof(double) ? __inline_isfinited((double)(__x)) : __inline_isfinitel((long double)(__x)));
}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
isfinite(_A1 __x) noexcept
{
    return __libcpp_isfinite((typename std::__promote<_A1>::type)__x);
}







template <class _A1>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isinf(_A1 __x) noexcept
{
    return ( sizeof(__x) == sizeof(float) ? __inline_isinff((float)(__x)) : sizeof(__x) == sizeof(double) ? __inline_isinfd((double)(__x)) : __inline_isinfl((long double)(__x)));
}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
isinf(_A1 __x) noexcept
{
    return __libcpp_isinf((typename std::__promote<_A1>::type)__x);
}







template <class _A1>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isnan(_A1 __x) noexcept
{
    return ( sizeof(__x) == sizeof(float) ? __inline_isnanf((float)(__x)) : sizeof(__x) == sizeof(double) ? __inline_isnand((double)(__x)) : __inline_isnanl((long double)(__x)));
}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
isnan(_A1 __x) noexcept
{
    return __libcpp_isnan((typename std::__promote<_A1>::type)__x);
}







template <class _A1>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isnormal(_A1 __x) noexcept
{
    return ( sizeof(__x) == sizeof(float) ? __inline_isnormalf((float)(__x)) : sizeof(__x) == sizeof(double) ? __inline_isnormald((double)(__x)) : __inline_isnormall((long double)(__x)));
}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
isnormal(_A1 __x) noexcept
{
    return __libcpp_isnormal((typename std::__promote<_A1>::type)__x);
}







template <class _A1, class _A2>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isgreater(_A1 __x, _A2 __y) noexcept
{
    return __builtin_isgreater((__x),(__y));
}



template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if
<
    std::is_arithmetic<_A1>::value &&
    std::is_arithmetic<_A2>::value,
    bool
>::type
isgreater(_A1 __x, _A2 __y) noexcept
{
    typedef typename std::__promote<_A1, _A2>::type type;
    return __libcpp_isgreater((type)__x, (type)__y);
}







template <class _A1, class _A2>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isgreaterequal(_A1 __x, _A2 __y) noexcept
{
    return __builtin_isgreaterequal((__x),(__y));
}



template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if
<
    std::is_arithmetic<_A1>::value &&
    std::is_arithmetic<_A2>::value,
    bool
>::type
isgreaterequal(_A1 __x, _A2 __y) noexcept
{
    typedef typename std::__promote<_A1, _A2>::type type;
    return __libcpp_isgreaterequal((type)__x, (type)__y);
}







template <class _A1, class _A2>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isless(_A1 __x, _A2 __y) noexcept
{
    return __builtin_isless((__x),(__y));
}



template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if
<
    std::is_arithmetic<_A1>::value &&
    std::is_arithmetic<_A2>::value,
    bool
>::type
isless(_A1 __x, _A2 __y) noexcept
{
    typedef typename std::__promote<_A1, _A2>::type type;
    return __libcpp_isless((type)__x, (type)__y);
}







template <class _A1, class _A2>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_islessequal(_A1 __x, _A2 __y) noexcept
{
    return __builtin_islessequal((__x),(__y));
}



template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if
<
    std::is_arithmetic<_A1>::value &&
    std::is_arithmetic<_A2>::value,
    bool
>::type
islessequal(_A1 __x, _A2 __y) noexcept
{
    typedef typename std::__promote<_A1, _A2>::type type;
    return __libcpp_islessequal((type)__x, (type)__y);
}







template <class _A1, class _A2>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_islessgreater(_A1 __x, _A2 __y) noexcept
{
    return __builtin_islessgreater((__x),(__y));
}



template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if
<
    std::is_arithmetic<_A1>::value &&
    std::is_arithmetic<_A2>::value,
    bool
>::type
islessgreater(_A1 __x, _A2 __y) noexcept
{
    typedef typename std::__promote<_A1, _A2>::type type;
    return __libcpp_islessgreater((type)__x, (type)__y);
}







template <class _A1, class _A2>
__attribute__ ((__visibility__("hidden"), __always_inline__))
bool
__libcpp_isunordered(_A1 __x, _A2 __y) noexcept
{
    return __builtin_isunordered((__x),(__y));
}



template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename std::enable_if
<
    std::is_arithmetic<_A1>::value &&
    std::is_arithmetic<_A2>::value,
    bool
>::type
isunordered(_A1 __x, _A2 __y) noexcept
{
    typedef typename std::__promote<_A1, _A2>::type type;
    return __libcpp_isunordered((type)__x, (type)__y);
}



namespace std {inline namespace __1 {

using ::signbit;
using ::fpclassify;
using ::isfinite;
using ::isinf;
using ::isnan;
using ::isnormal;
using ::isgreater;
using ::isgreaterequal;
using ::isless;
using ::islessequal;
using ::islessgreater;
using ::isunordered;
using ::isunordered;

using ::float_t;
using ::double_t;




inline __attribute__ ((__visibility__("hidden"), __always_inline__))
float
abs(float __x) noexcept {return fabsf(__x);}

inline __attribute__ ((__visibility__("hidden"), __always_inline__))
double
abs(double __x) noexcept {return fabs(__x);}

inline __attribute__ ((__visibility__("hidden"), __always_inline__))
long double
abs(long double __x) noexcept {return fabsl(__x);}






using ::acos;
using ::acosf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float acos(float __x) noexcept {return acosf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double acos(long double __x) noexcept {return acosl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
acos(_A1 __x) noexcept {return acos((double)__x);}



using ::asin;
using ::asinf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float asin(float __x) noexcept {return asinf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double asin(long double __x) noexcept {return asinl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
asin(_A1 __x) noexcept {return asin((double)__x);}



using ::atan;
using ::atanf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float atan(float __x) noexcept {return atanf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double atan(long double __x) noexcept {return atanl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
atan(_A1 __x) noexcept {return atan((double)__x);}



using ::atan2;
using ::atan2f;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float atan2(float __y, float __x) noexcept {return atan2f(__y, __x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double atan2(long double __y, long double __x) noexcept {return atan2l(__y, __x);}


template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
atan2(_A1 __y, _A2 __x) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return atan2((__result_type)__y, (__result_type)__x);
}



using ::ceil;
using ::ceilf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float ceil(float __x) noexcept {return ceilf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double ceil(long double __x) noexcept {return ceill(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
ceil(_A1 __x) noexcept {return ceil((double)__x);}



using ::cos;
using ::cosf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float cos(float __x) noexcept {return cosf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double cos(long double __x) noexcept {return cosl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
cos(_A1 __x) noexcept {return cos((double)__x);}



using ::cosh;
using ::coshf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float cosh(float __x) noexcept {return coshf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double cosh(long double __x) noexcept {return coshl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
cosh(_A1 __x) noexcept {return cosh((double)__x);}




using ::exp;
using ::expf;




inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float exp(float __x) noexcept {return expf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double exp(long double __x) noexcept {return expl(__x);}



template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
exp(_A1 __x) noexcept {return exp((double)__x);}



using ::fabs;
using ::fabsf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float fabs(float __x) noexcept {return fabsf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double fabs(long double __x) noexcept {return fabsl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
fabs(_A1 __x) noexcept {return fabs((double)__x);}



using ::floor;
using ::floorf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float floor(float __x) noexcept {return floorf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double floor(long double __x) noexcept {return floorl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
floor(_A1 __x) noexcept {return floor((double)__x);}




using ::fmod;
using ::fmodf;



inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float fmod(float __x, float __y) noexcept {return fmodf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double fmod(long double __x, long double __y) noexcept {return fmodl(__x, __y);}


template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
fmod(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return fmod((__result_type)__x, (__result_type)__y);
}




using ::frexp;
using ::frexpf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float frexp(float __x, int* __e) noexcept {return frexpf(__x, __e);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double frexp(long double __x, int* __e) noexcept {return frexpl(__x, __e);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
frexp(_A1 __x, int* __e) noexcept {return frexp((double)__x, __e);}



using ::ldexp;
using ::ldexpf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float ldexp(float __x, int __e) noexcept {return ldexpf(__x, __e);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double ldexp(long double __x, int __e) noexcept {return ldexpl(__x, __e);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
ldexp(_A1 __x, int __e) noexcept {return ldexp((double)__x, __e);}




using ::log;
using ::logf;



inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float log(float __x) noexcept {return logf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double log(long double __x) noexcept {return logl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
log(_A1 __x) noexcept {return log((double)__x);}




using ::log10;
using ::log10f;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float log10(float __x) noexcept {return log10f(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double log10(long double __x) noexcept {return log10l(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
log10(_A1 __x) noexcept {return log10((double)__x);}



using ::modf;
using ::modff;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float modf(float __x, float* __y) noexcept {return modff(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double modf(long double __x, long double* __y) noexcept {return modfl(__x, __y);}





using ::pow;
using ::powf;




inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float pow(float __x, float __y) noexcept {return powf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double pow(long double __x, long double __y) noexcept {return powl(__x, __y);}


template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
pow(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return pow((__result_type)__x, (__result_type)__y);
}



using ::sin;
using ::sinf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float sin(float __x) noexcept {return sinf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double sin(long double __x) noexcept {return sinl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
sin(_A1 __x) noexcept {return sin((double)__x);}



using ::sinh;
using ::sinhf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float sinh(float __x) noexcept {return sinhf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double sinh(long double __x) noexcept {return sinhl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
sinh(_A1 __x) noexcept {return sinh((double)__x);}




using ::sqrt;
using ::sqrtf;



inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float sqrt(float __x) noexcept {return sqrtf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double sqrt(long double __x) noexcept {return sqrtl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
sqrt(_A1 __x) noexcept {return sqrt((double)__x);}



using ::tan;
using ::tanf;



inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float tan(float __x) noexcept {return tanf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double tan(long double __x) noexcept {return tanl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
tan(_A1 __x) noexcept {return tan((double)__x);}



using ::tanh;
using ::tanhf;


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float tanh(float __x) noexcept {return tanhf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double tanh(long double __x) noexcept {return tanhl(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
tanh(_A1 __x) noexcept {return tanh((double)__x);}




using ::acosh;
using ::acoshf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float acosh(float __x) noexcept {return acoshf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double acosh(long double __x) noexcept {return acoshl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
acosh(_A1 __x) noexcept {return acosh((double)__x);}





using ::asinh;
using ::asinhf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float asinh(float __x) noexcept {return asinhf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double asinh(long double __x) noexcept {return asinhl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
asinh(_A1 __x) noexcept {return asinh((double)__x);}





using ::atanh;
using ::atanhf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float atanh(float __x) noexcept {return atanhf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double atanh(long double __x) noexcept {return atanhl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
atanh(_A1 __x) noexcept {return atanh((double)__x);}





using ::cbrt;
using ::cbrtf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float cbrt(float __x) noexcept {return cbrtf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double cbrt(long double __x) noexcept {return cbrtl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
cbrt(_A1 __x) noexcept {return cbrt((double)__x);}




using ::copysign;
using ::copysignf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float copysign(float __x, float __y) noexcept {return copysignf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double copysign(long double __x, long double __y) noexcept {return copysignl(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
copysign(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return copysign((__result_type)__x, (__result_type)__y);
}





using ::erf;
using ::erff;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float erf(float __x) noexcept {return erff(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double erf(long double __x) noexcept {return erfl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
erf(_A1 __x) noexcept {return erf((double)__x);}



using ::erfc;
using ::erfcf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float erfc(float __x) noexcept {return erfcf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double erfc(long double __x) noexcept {return erfcl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
erfc(_A1 __x) noexcept {return erfc((double)__x);}



using ::exp2;
using ::exp2f;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float exp2(float __x) noexcept {return exp2f(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double exp2(long double __x) noexcept {return exp2l(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
exp2(_A1 __x) noexcept {return exp2((double)__x);}



using ::expm1;
using ::expm1f;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float expm1(float __x) noexcept {return expm1f(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double expm1(long double __x) noexcept {return expm1l(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
expm1(_A1 __x) noexcept {return expm1((double)__x);}



using ::fdim;
using ::fdimf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float fdim(float __x, float __y) noexcept {return fdimf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double fdim(long double __x, long double __y) noexcept {return fdiml(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
fdim(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return fdim((__result_type)__x, (__result_type)__y);
}



using ::fmaf;
using ::fma;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float fma(float __x, float __y, float __z) noexcept {return fmaf(__x, __y, __z);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double fma(long double __x, long double __y, long double __z) noexcept {return fmal(__x, __y, __z);}

template <class _A1, class _A2, class _A3>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value &&
    is_arithmetic<_A3>::value,
    typename __promote<_A1, _A2, _A3>::type
>::type
fma(_A1 __x, _A2 __y, _A3 __z) noexcept
{
    typedef typename __promote<_A1, _A2, _A3>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value &&
                      is_same<_A3, __result_type>::value)), "");
    return fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
}



using ::fmax;
using ::fmaxf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float fmax(float __x, float __y) noexcept {return fmaxf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double fmax(long double __x, long double __y) noexcept {return fmaxl(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
fmax(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return fmax((__result_type)__x, (__result_type)__y);
}



using ::fmin;
using ::fminf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float fmin(float __x, float __y) noexcept {return fminf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double fmin(long double __x, long double __y) noexcept {return fminl(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
fmin(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return fmin((__result_type)__x, (__result_type)__y);
}



using ::hypot;
using ::hypotf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float hypot(float __x, float __y) noexcept {return hypotf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double hypot(long double __x, long double __y) noexcept {return hypotl(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
hypot(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return hypot((__result_type)__x, (__result_type)__y);
}



using ::ilogb;
using ::ilogbf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) int ilogb(float __x) noexcept {return ilogbf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) int ilogb(long double __x) noexcept {return ilogbl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, int>::type
ilogb(_A1 __x) noexcept {return ilogb((double)__x);}



using ::lgamma;
using ::lgammaf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float lgamma(float __x) noexcept {return lgammaf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double lgamma(long double __x) noexcept {return lgammal(__x);}


template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
lgamma(_A1 __x) noexcept {return lgamma((double)__x);}




using ::llrint;
using ::llrintf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long long llrint(float __x) noexcept {return llrintf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long long llrint(long double __x) noexcept {return llrintl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, long long>::type
llrint(_A1 __x) noexcept {return llrint((double)__x);}



using ::llround;
using ::llroundf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long long llround(float __x) noexcept {return llroundf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long long llround(long double __x) noexcept {return llroundl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, long long>::type
llround(_A1 __x) noexcept {return llround((double)__x);}



using ::log1p;
using ::log1pf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float log1p(float __x) noexcept {return log1pf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double log1p(long double __x) noexcept {return log1pl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
log1p(_A1 __x) noexcept {return log1p((double)__x);}



using ::log2;
using ::log2f;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float log2(float __x) noexcept {return log2f(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double log2(long double __x) noexcept {return log2l(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
log2(_A1 __x) noexcept {return log2((double)__x);}



using ::logb;
using ::logbf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float logb(float __x) noexcept {return logbf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double logb(long double __x) noexcept {return logbl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
logb(_A1 __x) noexcept {return logb((double)__x);}



using ::lrint;
using ::lrintf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long lrint(float __x) noexcept {return lrintf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long lrint(long double __x) noexcept {return lrintl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, long>::type
lrint(_A1 __x) noexcept {return lrint((double)__x);}



using ::lround;
using ::lroundf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long lround(float __x) noexcept {return lroundf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long lround(long double __x) noexcept {return lroundl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, long>::type
lround(_A1 __x) noexcept {return lround((double)__x);}







using ::nan;
using ::nanf;







using ::nearbyint;
using ::nearbyintf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float nearbyint(float __x) noexcept {return nearbyintf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double nearbyint(long double __x) noexcept {return nearbyintl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
nearbyint(_A1 __x) noexcept {return nearbyint((double)__x);}



using ::nextafter;
using ::nextafterf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float nextafter(float __x, float __y) noexcept {return nextafterf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double nextafter(long double __x, long double __y) noexcept {return nextafterl(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
nextafter(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return nextafter((__result_type)__x, (__result_type)__y);
}



using ::nexttoward;
using ::nexttowardf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float nexttoward(float __x, long double __y) noexcept {return nexttowardf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double nexttoward(long double __x, long double __y) noexcept {return nexttowardl(__x, __y);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
nexttoward(_A1 __x, long double __y) noexcept {return nexttoward((double)__x, __y);}



using ::remainder;
using ::remainderf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float remainder(float __x, float __y) noexcept {return remainderf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double remainder(long double __x, long double __y) noexcept {return remainderl(__x, __y);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
remainder(_A1 __x, _A2 __y) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return remainder((__result_type)__x, (__result_type)__y);
}



using ::remquo;
using ::remquof;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float remquo(float __x, float __y, int* __z) noexcept {return remquof(__x, __y, __z);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double remquo(long double __x, long double __y, int* __z) noexcept {return remquol(__x, __y, __z);}

template <class _A1, class _A2>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if
<
    is_arithmetic<_A1>::value &&
    is_arithmetic<_A2>::value,
    typename __promote<_A1, _A2>::type
>::type
remquo(_A1 __x, _A2 __y, int* __z) noexcept
{
    typedef typename __promote<_A1, _A2>::type __result_type;
    static_assert((!(is_same<_A1, __result_type>::value &&
                      is_same<_A2, __result_type>::value)), "");
    return remquo((__result_type)__x, (__result_type)__y, __z);
}



using ::rint;
using ::rintf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float rint(float __x) noexcept {return rintf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double rint(long double __x) noexcept {return rintl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
rint(_A1 __x) noexcept {return rint((double)__x);}



using ::round;
using ::roundf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float round(float __x) noexcept {return roundf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double round(long double __x) noexcept {return roundl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
round(_A1 __x) noexcept {return round((double)__x);}



using ::scalbln;
using ::scalblnf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float scalbln(float __x, long __y) noexcept {return scalblnf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double scalbln(long double __x, long __y) noexcept {return scalblnl(__x, __y);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
scalbln(_A1 __x, long __y) noexcept {return scalbln((double)__x, __y);}



using ::scalbn;
using ::scalbnf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float scalbn(float __x, int __y) noexcept {return scalbnf(__x, __y);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double scalbn(long double __x, int __y) noexcept {return scalbnl(__x, __y);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
scalbn(_A1 __x, int __y) noexcept {return scalbn((double)__x, __y);}



using ::tgamma;
using ::tgammaf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float tgamma(float __x) noexcept {return tgammaf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double tgamma(long double __x) noexcept {return tgammal(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
tgamma(_A1 __x) noexcept {return tgamma((double)__x);}



using ::trunc;
using ::truncf;

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) float trunc(float __x) noexcept {return truncf(__x);}
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long double trunc(long double __x) noexcept {return truncl(__x);}

template <class _A1>
inline __attribute__ ((__visibility__("hidden"), __always_inline__))
typename enable_if<is_integral<_A1>::value, double>::type
trunc(_A1 __x) noexcept {return trunc((double)__x);}



using ::acosl;
using ::asinl;
using ::atanl;
using ::atan2l;
using ::ceill;
using ::cosl;
using ::coshl;
using ::expl;
using ::fabsl;
using ::floorl;
using ::fmodl;
using ::frexpl;
using ::ldexpl;
using ::logl;
using ::log10l;
using ::modfl;
using ::powl;
using ::sinl;
using ::sinhl;
using ::sqrtl;
using ::tanl;

using ::tanhl;
using ::acoshl;
using ::asinhl;
using ::atanhl;
using ::cbrtl;

using ::copysignl;

using ::erfl;
using ::erfcl;
using ::exp2l;
using ::expm1l;
using ::fdiml;
using ::fmal;
using ::fmaxl;
using ::fminl;
using ::hypotl;
using ::ilogbl;
using ::lgammal;
using ::llrintl;
using ::llroundl;
using ::log1pl;
using ::log2l;
using ::logbl;
using ::lrintl;
using ::lroundl;
using ::nanl;
using ::nearbyintl;
using ::nextafterl;
using ::nexttowardl;
using ::remainderl;
using ::remquol;
using ::rintl;
using ::roundl;
using ::scalblnl;
using ::scalbnl;
using ::tgammal;
using ::truncl;






} }
# 8485 "/usr/local/cuda/include/math_functions.h" 2
# 1 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstdlib" 1 3
# 93 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstdlib" 3


namespace std {inline namespace __1 {

using ::size_t;
using ::div_t;
using ::ldiv_t;

using ::lldiv_t;

using ::atof;
using ::atoi;
using ::atol;

using ::atoll;

using ::strtod;
using ::strtof;
using ::strtold;
using ::strtol;

using ::strtoll;

using ::strtoul;

using ::strtoull;

using ::rand;
using ::srand;
using ::calloc;
using ::free;
using ::malloc;
using ::realloc;
using ::abort;
using ::atexit;
using ::exit;
using ::_Exit;
using ::getenv;
using ::system;
using ::bsearch;
using ::qsort;
using ::abs;
using ::labs;

using ::llabs;

using ::div;
using ::ldiv;

using ::lldiv;

using ::mblen;
using ::mbtowc;
using ::wctomb;
using ::mbstowcs;
using ::wcstombs;
# 159 "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/cstdlib" 3
inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long abs( long __x) noexcept {return labs(__x);}

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) long long abs(long long __x) noexcept {return llabs(__x);}


inline __attribute__ ((__visibility__("hidden"), __always_inline__)) ldiv_t div( long __x, long __y) noexcept {return ldiv(__x, __y);}

inline __attribute__ ((__visibility__("hidden"), __always_inline__)) lldiv_t div(long long __x, long long __y) noexcept {return lldiv(__x, __y);}



} }
# 8486 "/usr/local/cuda/include/math_functions.h" 2
# 8522 "/usr/local/cuda/include/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);
# 8603 "/usr/local/cuda/include/math_functions.h"
namespace __gnu_cxx
{


extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int a);


}




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;
# 8984 "/usr/local/cuda/include/math_functions.h"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc++11-extensions"

namespace std {inline namespace __1 {
# 9033 "/usr/local/cuda/include/math_functions.h"
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long int abs(long int) throw();

extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) long long int abs(long long int) throw();

extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float abs(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double abs(double) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fabs(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ceil(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float floor(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sqrt(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float, float) throw();




extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float log10(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float fmod(float, float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float modf(float, float*) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float exp(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float frexp(float, int*) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float ldexp(float, int) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float asin(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sin(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float sinh(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float acos(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cos(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float cosh(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float atan2(float, float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tan(float) throw();
extern __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float tanh(float) throw();



} }

#pragma clang diagnostic pop
# 9125 "/usr/local/cuda/include/math_functions.h"
static inline __attribute__((host)) __attribute__((device)) float logb(float a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static inline __attribute__((host)) __attribute__((device)) unsigned int min(unsigned int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) unsigned int min(int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) unsigned int min(unsigned int a, int b);

static inline __attribute__((host)) __attribute__((device)) long long int min(long long int a, long long int b);

static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(unsigned long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) unsigned long long int min(unsigned long long int a, long long int b);

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

static inline __attribute__((host)) __attribute__((device)) double min(double a, double b);

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

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

static inline __attribute__((host)) __attribute__((device)) unsigned int max(unsigned int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) unsigned int max(int a, unsigned int b);

static inline __attribute__((host)) __attribute__((device)) unsigned int max(unsigned int a, int b);

static inline __attribute__((host)) __attribute__((device)) long long int max(long long int a, long long int b);

static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(unsigned long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(long long int a, unsigned long long int b);

static inline __attribute__((host)) __attribute__((device)) unsigned long long int max(unsigned long long int a, long long int b);

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

static inline __attribute__((host)) __attribute__((device)) double max(double a, double b);

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

static inline __attribute__((host)) __attribute__((device)) double max(double a, float b);
# 9822 "/usr/local/cuda/include/math_functions.h"
# 1 "/usr/local/cuda/include/math_functions.hpp" 1
# 67 "/usr/local/cuda/include/math_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/math_functions.hpp" 2
# 134 "/usr/local/cuda/include/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 __signbitd(x); }
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int signbit(long double x) { return __signbitl(x);}

__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(float x) { return __isfinitef(x); }
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(double x) { return __isfinited(x); }
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isfinite(long double x) { return __isfinite(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 __isnand(x); }
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isnan(long double x) { return __isnan(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 __isinfd(x); }
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) int isinf(long double x) { return __isinf(x); }


extern "C" __attribute__((host)) __attribute__((device)) float powif(float, int);
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) float pow(float a, int b) throw()
{

  return powif(a, (b));



}
extern "C" __attribute__((host)) __attribute__((device)) double powi(double, int);
__inline__ __attribute__((always_inline)) __attribute__((host)) __attribute__((device)) __attribute__((cudart_builtin)) double pow(double a, int b) throw()
{

  return powi(a, (b));



}
# 478 "/usr/local/cuda/include/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)) float copysign(float a, double b)
{
  return copysignf(a, (float)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 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 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);
}
# 9823 "/usr/local/cuda/include/math_functions.h" 2



# 1 "/usr/local/cuda/include/math_functions_dbl_ptx3.h" 1
# 262 "/usr/local/cuda/include/math_functions_dbl_ptx3.h"
# 1 "/usr/local/cuda/include/math_functions_dbl_ptx3.hpp" 1
# 263 "/usr/local/cuda/include/math_functions_dbl_ptx3.h" 2
# 9827 "/usr/local/cuda/include/math_functions.h" 2
# 220 "/usr/local/cuda/include/common_functions.h" 2
# 105 "/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
# 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>();
  }

};
# 106 "/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
# 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;
  }

};
# 107 "/usr/local/cuda/include/cuda_runtime.h" 2
# 1 "/usr/local/cuda/include/device_functions.h" 1
# 69 "/usr/local/cuda/include/device_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/device_functions.h" 2
# 79 "/usr/local/cuda/include/device_functions.h"
extern "C"
{
# 90 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __mulhi(int x, int y);
# 100 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __umulhi(unsigned int x, unsigned int y);
# 110 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) long long int __mul64hi(long long int x, long long int y);
# 120 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y);
# 129 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __int_as_float(int x);
# 138 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __float_as_int(float x);
__attribute__((device)) __attribute__((device_builtin)) void __syncthreads(void);
__attribute__((device)) __attribute__((device_builtin)) void __prof_trigger(int);
__attribute__((device)) __attribute__((device_builtin)) void __threadfence(void);
__attribute__((device)) __attribute__((device_builtin)) void __threadfence_block(void);
__attribute__((device)) __attribute__((device_builtin)) void __trap(void);
__attribute__((device)) __attribute__((device_builtin)) void __brkpt(int c = 0);
# 167 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __saturatef(float x);
# 236 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __sad(int x, int y, unsigned int z);
# 304 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __usad(unsigned int x, unsigned int y, unsigned int z);
# 314 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __mul24(int x, int y);
# 324 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __umul24(unsigned int x, unsigned int y);
# 337 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float fdividef(float x, float y);
# 412 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fdividef(float x, float y);
__attribute__((device)) __attribute__((device_builtin)) double fdivide(double x, double y);
# 425 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __sinf(float x) ;
# 437 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __cosf(float x) ;
# 451 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __tanf(float x) ;
# 466 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) void __sincosf(float x, float *sptr, float *cptr) ;
# 516 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __expf(float x) ;
# 548 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __exp10f(float x) ;
# 574 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log2f(float x) ;
# 602 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __log10f(float x) ;
# 646 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __logf(float x) ;
# 689 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) __attribute__((cudart_builtin)) float __powf(float x, float y) ;
# 698 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __float2int_rn(float x);
# 707 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __float2int_rz(float x);
# 716 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __float2int_ru(float);
# 725 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __float2int_rd(float x);
# 734 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __float2uint_rn(float x);
# 743 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __float2uint_rz(float x);
# 752 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __float2uint_ru(float x);
# 761 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __float2uint_rd(float x);
# 770 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __int2float_rn(int x);
# 779 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __int2float_rz(int x);
# 788 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __int2float_ru(int x);
# 797 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __int2float_rd(int x);
# 806 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __uint2float_rn(unsigned int x);
# 815 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __uint2float_rz(unsigned int x);
# 824 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __uint2float_ru(unsigned int x);
# 833 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __uint2float_rd(unsigned int x);
# 842 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) long long int __float2ll_rn(float x);
# 851 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) long long int __float2ll_rz(float x);
# 860 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) long long int __float2ll_ru(float x);
# 869 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) long long int __float2ll_rd(float x);
# 878 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __float2ull_rn(float x);
# 887 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __float2ull_rz(float x);
# 896 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __float2ull_ru(float x);
# 905 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __float2ull_rd(float x);
# 914 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ll2float_rn(long long int x);
# 923 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ll2float_rz(long long int x);
# 932 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ll2float_ru(long long int x);
# 941 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ll2float_rd(long long int x);
# 950 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ull2float_rn(unsigned long long int x);
# 959 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ull2float_rz(unsigned long long int x);
# 968 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ull2float_ru(unsigned long long int x);
# 977 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __ull2float_rd(unsigned long long int x);
# 986 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned short __float2half_rn(float x);
# 995 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __half2float(unsigned short x);
# 1007 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fadd_rn(float x, float y);
# 1019 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fadd_rz(float x, float y);
# 1031 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fadd_ru(float x, float y);
# 1043 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fadd_rd(float x, float y);
# 1055 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsub_rn(float x, float y);
# 1067 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsub_rz(float x, float y);
# 1079 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsub_ru(float x, float y);
# 1091 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsub_rd(float x, float y);
# 1103 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmul_rn(float x, float y);
# 1115 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmul_rz(float x, float y);
# 1127 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmul_ru(float x, float y);
# 1139 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmul_rd(float x, float y);
# 1292 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmaf_rn(float x, float y, float z);
# 1445 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmaf_rz(float x, float y, float z);
# 1598 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmaf_ru(float x, float y, float z);
# 1751 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fmaf_rd(float x, float y, float z);
# 1784 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __frcp_rn(float x);
# 1817 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __frcp_rz(float x);
# 1850 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __frcp_ru(float x);
# 1883 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __frcp_rd(float x);
# 1914 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsqrt_rn(float x);
# 1945 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsqrt_rz(float x);
# 1976 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsqrt_ru(float x);
# 2007 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fsqrt_rd(float x);
# 2046 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __frsqrt_rn(float x);
# 2057 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fdiv_rn(float x, float y);
# 2068 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fdiv_rz(float x, float y);
# 2079 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fdiv_ru(float x, float y);
# 2090 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) float __fdiv_rd(float x, float y);
# 2099 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __clz(int x);
# 2110 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __ffs(int x);
# 2119 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __popc(unsigned int x);
# 2128 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __brev(unsigned int x);
# 2137 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __clzll(long long int x);
# 2148 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __ffsll(long long int x);
# 2159 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __popcll(unsigned long long int x);
# 2168 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __brevll(unsigned long long int x);
# 2192 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s);
# 2204 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __hadd(int, int);
# 2217 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __rhadd(int, int);
# 2229 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __uhadd(unsigned int, unsigned int);
# 2242 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __urhadd(unsigned int, unsigned int);
# 2252 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) int __double2int_rz(double);
# 2261 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rz(double);
# 2270 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rz(double);
# 2279 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rz(double);
__attribute__((device)) __attribute__((device_builtin)) unsigned int __pm0(void);
__attribute__((device)) __attribute__((device_builtin)) unsigned int __pm1(void);
__attribute__((device)) __attribute__((device_builtin)) unsigned int __pm2(void);
__attribute__((device)) __attribute__((device_builtin)) unsigned int __pm3(void);
# 2300 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabs2(unsigned int a);
# 2311 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabsss2(unsigned int a);
# 2322 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vadd2(unsigned int a, unsigned int b);
# 2333 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vaddss2 (unsigned int a, unsigned int b);
# 2343 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vaddus2 (unsigned int a, unsigned int b);
# 2354 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vavgs2(unsigned int a, unsigned int b);
# 2365 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vavgu2(unsigned int a, unsigned int b);
# 2376 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vhaddu2(unsigned int a, unsigned int b);
# 2387 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpeq2(unsigned int a, unsigned int b);
# 2398 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpges2(unsigned int a, unsigned int b);
# 2409 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpgeu2(unsigned int a, unsigned int b);
# 2420 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpgts2(unsigned int a, unsigned int b);
# 2431 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpgtu2(unsigned int a, unsigned int b);
# 2442 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmples2(unsigned int a, unsigned int b);
# 2454 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpleu2(unsigned int a, unsigned int b);
# 2465 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmplts2(unsigned int a, unsigned int b);
# 2476 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpltu2(unsigned int a, unsigned int b);
# 2487 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpne2(unsigned int a, unsigned int b);
# 2498 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabsdiffu2(unsigned int a, unsigned int b);
# 2509 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vmaxs2(unsigned int a, unsigned int b);
# 2520 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vmaxu2(unsigned int a, unsigned int b);
# 2531 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vmins2(unsigned int a, unsigned int b);
# 2542 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vminu2(unsigned int a, unsigned int b);
# 2553 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vseteq2(unsigned int a, unsigned int b);
# 2564 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetges2(unsigned int a, unsigned int b);
# 2575 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetgeu2(unsigned int a, unsigned int b);
# 2586 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetgts2(unsigned int a, unsigned int b);
# 2597 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetgtu2(unsigned int a, unsigned int b);
# 2608 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetles2(unsigned int a, unsigned int b);
# 2619 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetleu2(unsigned int a, unsigned int b);
# 2630 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetlts2(unsigned int a, unsigned int b);
# 2641 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetltu2(unsigned int a, unsigned int b);
# 2652 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetne2(unsigned int a, unsigned int b);
# 2663 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsadu2(unsigned int a, unsigned int b);
# 2674 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsub2(unsigned int a, unsigned int b);
# 2685 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsubss2 (unsigned int a, unsigned int b);
# 2696 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsubus2 (unsigned int a, unsigned int b);
# 2706 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vneg2(unsigned int a);
# 2716 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vnegss2(unsigned int a);
# 2727 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabsdiffs2(unsigned int a, unsigned int b);
# 2738 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsads2(unsigned int a, unsigned int b);
# 2748 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabs4(unsigned int a);
# 2759 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabsss4(unsigned int a);
# 2770 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vadd4(unsigned int a, unsigned int b);
# 2781 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vaddss4 (unsigned int a, unsigned int b);
# 2791 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vaddus4 (unsigned int a, unsigned int b);
# 2802 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vavgs4(unsigned int a, unsigned int b);
# 2813 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vavgu4(unsigned int a, unsigned int b);
# 2824 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vhaddu4(unsigned int a, unsigned int b);
# 2835 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpeq4(unsigned int a, unsigned int b);
# 2846 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpges4(unsigned int a, unsigned int b);
# 2857 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpgeu4(unsigned int a, unsigned int b);
# 2868 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpgts4(unsigned int a, unsigned int b);
# 2879 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpgtu4(unsigned int a, unsigned int b);
# 2890 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmples4(unsigned int a, unsigned int b);
# 2901 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpleu4(unsigned int a, unsigned int b);
# 2912 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmplts4(unsigned int a, unsigned int b);
# 2923 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpltu4(unsigned int a, unsigned int b);
# 2934 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vcmpne4(unsigned int a, unsigned int b);
# 2945 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabsdiffu4(unsigned int a, unsigned int b);
# 2956 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vmaxs4(unsigned int a, unsigned int b);
# 2967 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vmaxu4(unsigned int a, unsigned int b);
# 2978 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vmins4(unsigned int a, unsigned int b);
# 2989 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vminu4(unsigned int a, unsigned int b);
# 3000 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vseteq4(unsigned int a, unsigned int b);
# 3011 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetles4(unsigned int a, unsigned int b);
# 3022 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetleu4(unsigned int a, unsigned int b);
# 3033 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetlts4(unsigned int a, unsigned int b);
# 3044 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetltu4(unsigned int a, unsigned int b);
# 3055 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetges4(unsigned int a, unsigned int b);
# 3066 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetgeu4(unsigned int a, unsigned int b);
# 3077 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetgts4(unsigned int a, unsigned int b);
# 3088 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetgtu4(unsigned int a, unsigned int b);
# 3099 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsetne4(unsigned int a, unsigned int b);
# 3110 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsadu4(unsigned int a, unsigned int b);
# 3121 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsub4(unsigned int a, unsigned int b);
# 3132 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsubss4(unsigned int a, unsigned int b);
# 3143 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsubus4(unsigned int a, unsigned int b);
# 3153 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vneg4(unsigned int a);
# 3163 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vnegss4(unsigned int a);
# 3174 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vabsdiffs4(unsigned int a, unsigned int b);
# 3185 "/usr/local/cuda/include/device_functions.h"
__attribute__((device)) __attribute__((device_builtin)) unsigned int __vsads4(unsigned int a, unsigned int b);






}







static __inline__ __attribute__((device)) int mulhi(int a, int b);

static __inline__ __attribute__((device)) unsigned int mulhi(unsigned int a, unsigned int b);

static __inline__ __attribute__((device)) unsigned int mulhi(int a, unsigned int b);

static __inline__ __attribute__((device)) unsigned int mulhi(unsigned int a, int b);

static __inline__ __attribute__((device)) long long int mul64hi(long long int a, long long int b);

static __inline__ __attribute__((device)) unsigned long long int mul64hi(unsigned long long int a, unsigned long long int b);

static __inline__ __attribute__((device)) unsigned long long int mul64hi(long long int a, unsigned long long int b);

static __inline__ __attribute__((device)) unsigned long long int mul64hi(unsigned long long int a, long long int b);

static __inline__ __attribute__((device)) int float_as_int(float a);

static __inline__ __attribute__((device)) float int_as_float(int a);

static __inline__ __attribute__((device)) float saturate(float a);

static __inline__ __attribute__((device)) int mul24(int a, int b);

static __inline__ __attribute__((device)) unsigned int umul24(unsigned int a, unsigned int b);

static __inline__ __attribute__((device)) void trap(void);


static __inline__ __attribute__((device)) void brkpt(int c = 0);

static __inline__ __attribute__((device)) void syncthreads(void);

static __inline__ __attribute__((device)) void prof_trigger(int e);

static __inline__ __attribute__((device)) void threadfence(bool global = true);

static __inline__ __attribute__((device)) int float2int(float a, enum cudaRoundMode mode = cudaRoundZero);

static __inline__ __attribute__((device)) unsigned int float2uint(float a, enum cudaRoundMode mode = cudaRoundZero);

static __inline__ __attribute__((device)) float int2float(int a, enum cudaRoundMode mode = cudaRoundNearest);

static __inline__ __attribute__((device)) float uint2float(unsigned int a, enum cudaRoundMode mode = cudaRoundNearest);
# 4183 "/usr/local/cuda/include/device_functions.h"
# 1 "/usr/local/cuda/include/device_functions.hpp" 1
# 69 "/usr/local/cuda/include/device_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/device_functions.hpp" 2
# 79 "/usr/local/cuda/include/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)) 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)) void trap(void)
{
  __trap();
}


static __inline__ __attribute__((device)) void brkpt(int c)
{
  __brkpt(c);
}

static __inline__ __attribute__((device)) void syncthreads(void)
{
  __syncthreads();
}

static __inline__ __attribute__((device)) void prof_trigger(int e)
{
       if (e == 0) __prof_trigger( 0);
  else if (e == 1) __prof_trigger( 1);
  else if (e == 2) __prof_trigger( 2);
  else if (e == 3) __prof_trigger( 3);
  else if (e == 4) __prof_trigger( 4);
  else if (e == 5) __prof_trigger( 5);
  else if (e == 6) __prof_trigger( 6);
  else if (e == 7) __prof_trigger( 7);
  else if (e == 8) __prof_trigger( 8);
  else if (e == 9) __prof_trigger( 9);
  else if (e == 10) __prof_trigger(10);
  else if (e == 11) __prof_trigger(11);
  else if (e == 12) __prof_trigger(12);
  else if (e == 13) __prof_trigger(13);
  else if (e == 14) __prof_trigger(14);
  else if (e == 15) __prof_trigger(15);
}

static __inline__ __attribute__((device)) void threadfence(bool global)
{
  global ? __threadfence() : __threadfence_block();
}

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);
}
# 4184 "/usr/local/cuda/include/device_functions.h" 2


# 1 "/usr/local/cuda/include/device_atomic_functions.h" 1
# 69 "/usr/local/cuda/include/device_atomic_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/device_atomic_functions.h" 2



extern "C"
{

extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicAdd(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicAdd(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicExch(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicExch(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicExch(float *address, float val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicMin(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicMin(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicMax(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicMax(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicInc(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicDec(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicAnd(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicAnd(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicOr(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicOr(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicXor(int *address, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicXor(unsigned int *address, unsigned int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __iAtomicCAS(int *address, int compare, int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __uAtomicCAS(unsigned int *address, unsigned int compare, unsigned int val);

}
# 105 "/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);
# 156 "/usr/local/cuda/include/device_atomic_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 157 "/usr/local/cuda/include/device_atomic_functions.h" 2



extern "C"
{

extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicAdd(unsigned long long int *address, unsigned long long int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicExch(unsigned long long int *address, unsigned long long int val);
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __ullAtomicCAS(unsigned long long int *address, unsigned long long int compare, unsigned long long int val);
extern __attribute__((device)) __attribute__((device_builtin)) int __any(int cond);
extern __attribute__((device)) __attribute__((device_builtin)) int __all(int cond);

}
# 178 "/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)) bool any(bool cond);

static __inline__ __attribute__((device)) bool all(bool cond);
# 195 "/usr/local/cuda/include/device_atomic_functions.h"
# 1 "/usr/local/cuda/include/device_atomic_functions.hpp" 1
# 69 "/usr/local/cuda/include/device_atomic_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/device_atomic_functions.hpp" 2








static __inline__ __attribute__((device)) int atomicAdd(int *address, int val)
{
  return __iAtomicAdd(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicAdd(unsigned int *address, unsigned int val)
{
  return __uAtomicAdd(address, val);
}

static __inline__ __attribute__((device)) int atomicSub(int *address, int val)
{
  return __iAtomicAdd(address, (unsigned int)-(int)val);
}

static __inline__ __attribute__((device)) unsigned int atomicSub(unsigned int *address, unsigned int val)
{
  return __uAtomicAdd(address, (unsigned int)-(int)val);
}

static __inline__ __attribute__((device)) int atomicExch(int *address, int val)
{
  return __iAtomicExch(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicExch(unsigned int *address, unsigned int val)
{
  return __uAtomicExch(address, val);
}

static __inline__ __attribute__((device)) float atomicExch(float *address, float val)
{
  return __fAtomicExch(address, val);
}

static __inline__ __attribute__((device)) int atomicMin(int *address, int val)
{
  return __iAtomicMin(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicMin(unsigned int *address, unsigned int val)
{
  return __uAtomicMin(address, val);
}

static __inline__ __attribute__((device)) int atomicMax(int *address, int val)
{
  return __iAtomicMax(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicMax(unsigned int *address, unsigned int val)
{
  return __uAtomicMax(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicInc(unsigned int *address, unsigned int val)
{
  return __uAtomicInc(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicDec(unsigned int *address, unsigned int val)
{
  return __uAtomicDec(address, val);
}

static __inline__ __attribute__((device)) int atomicAnd(int *address, int val)
{
  return __iAtomicAnd(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicAnd(unsigned int *address, unsigned int val)
{
  return __uAtomicAnd(address, val);
}

static __inline__ __attribute__((device)) int atomicOr(int *address, int val)
{
  return __iAtomicOr(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicOr(unsigned int *address, unsigned int val)
{
  return __uAtomicOr(address, val);
}

static __inline__ __attribute__((device)) int atomicXor(int *address, int val)
{
  return __iAtomicXor(address, val);
}

static __inline__ __attribute__((device)) unsigned int atomicXor(unsigned int *address, unsigned int val)
{
  return __uAtomicXor(address, val);
}

static __inline__ __attribute__((device)) int atomicCAS(int *address, int compare, int val)
{
  return __iAtomicCAS(address, compare, val);
}

static __inline__ __attribute__((device)) unsigned int atomicCAS(unsigned int *address, unsigned int compare, unsigned int val)
{
  return __uAtomicCAS(address, compare, val);
}
# 192 "/usr/local/cuda/include/device_atomic_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 193 "/usr/local/cuda/include/device_atomic_functions.hpp" 2








static __inline__ __attribute__((device)) unsigned long long int atomicAdd(unsigned long long int *address, unsigned long long int val)
{
  return __ullAtomicAdd(address, val);
}

static __inline__ __attribute__((device)) unsigned long long int atomicExch(unsigned long long int *address, unsigned long long int val)
{
  return __ullAtomicExch(address, 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)
{
  return __ullAtomicCAS(address, compare, val);
}

static __inline__ __attribute__((device)) bool any(bool cond)
{
  return (bool)__any((int)cond);
}

static __inline__ __attribute__((device)) bool all(bool cond)
{
  return (bool)__all((int)cond);
}
# 196 "/usr/local/cuda/include/device_atomic_functions.h" 2
# 4187 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/device_double_functions.h" 1
# 73 "/usr/local/cuda/include/device_double_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 74 "/usr/local/cuda/include/device_double_functions.h" 2




extern "C"
{
# 89 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double_as_longlong(double x);
# 98 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __longlong_as_double(long long int x);
# 255 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rn(double x, double y, double z);
# 412 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rz(double x, double y, double z);
# 569 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_ru(double x, double y, double z);
# 726 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __fma_rd(double x, double y, double z);
# 738 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rn(double x, double y);
# 750 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rz(double x, double y);
# 762 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_ru(double x, double y);
# 774 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dadd_rd(double x, double y);
# 786 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rn(double x, double y);
# 798 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rz(double x, double y);
# 810 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_ru(double x, double y);
# 822 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsub_rd(double x, double y);
# 834 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rn(double x, double y);
# 846 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rz(double x, double y);
# 858 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_ru(double x, double y);
# 870 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dmul_rd(double x, double y);
# 879 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rn(double x);
# 888 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rz(double x);
# 897 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_ru(double x);
# 906 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) float __double2float_rd(double x);
# 915 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rn(double x);
# 924 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_ru(double x);
# 933 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2int_rd(double x);
# 942 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rn(double x);
# 951 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_ru(double x);
# 960 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned int __double2uint_rd(double x);
# 969 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rn(double x);
# 978 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_ru(double x);
# 987 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) long long int __double2ll_rd(double x);
# 996 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_rn(double x);
# 1005 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) unsigned long long int __double2ull_ru(double x);
# 1014 "/usr/local/cuda/include/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);
# 1039 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rn(long long int x);
# 1048 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rz(long long int x);
# 1057 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_ru(long long int x);
# 1066 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ll2double_rd(long long int x);
# 1075 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rn(unsigned long long int x);
# 1084 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rz(unsigned long long int x);
# 1093 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_ru(unsigned long long int x);
# 1102 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ull2double_rd(unsigned long long int x);
# 1111 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2hiint(double x);
# 1120 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) int __double2loint(double x);
# 1130 "/usr/local/cuda/include/device_double_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __hiloint2double(int hi, int lo);

}
# 1141 "/usr/local/cuda/include/device_double_functions.h"
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);
# 1191 "/usr/local/cuda/include/device_double_functions.h"
# 1 "/usr/local/cuda/include/device_double_functions.hpp" 1
# 73 "/usr/local/cuda/include/device_double_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 74 "/usr/local/cuda/include/device_double_functions.hpp" 2
# 83 "/usr/local/cuda/include/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;
}
# 1192 "/usr/local/cuda/include/device_double_functions.h" 2
# 4188 "/usr/local/cuda/include/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



extern "C"
{

extern __attribute__((device)) __attribute__((device_builtin)) float __fAtomicAdd(float *address, float val);

}
# 85 "/usr/local/cuda/include/sm_20_atomic_functions.h"
static __inline__ __attribute__((device)) float atomicAdd(float *address, float val);







# 1 "/usr/local/cuda/include/sm_20_atomic_functions.hpp" 1
# 67 "/usr/local/cuda/include/sm_20_atomic_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/sm_20_atomic_functions.hpp" 2








static __inline__ __attribute__((device)) float atomicAdd(float *address, float val)
{
  return __fAtomicAdd(address, val);
}
# 93 "/usr/local/cuda/include/sm_20_atomic_functions.h" 2
# 4189 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_32_atomic_functions.h" 1
# 114 "/usr/local/cuda/include/sm_32_atomic_functions.h"
# 1 "/usr/local/cuda/include/sm_32_atomic_functions.hpp" 1
# 115 "/usr/local/cuda/include/sm_32_atomic_functions.h" 2
# 4190 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_35_atomic_functions.h" 1
# 4191 "/usr/local/cuda/include/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




extern "C"
{

extern __attribute__((device)) __attribute__((device_builtin)) void __threadfence_system(void);
# 87 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rn(double x, double y);
# 99 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rz(double x, double y);
# 111 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_ru(double x, double y);
# 123 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __ddiv_rd(double x, double y);
# 157 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rn(double x);
# 191 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rz(double x);
# 225 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_ru(double x);
# 259 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __drcp_rd(double x);
# 291 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rn(double x);
# 323 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_rz(double x);
# 355 "/usr/local/cuda/include/sm_20_intrinsics.h"
extern __attribute__((device)) __attribute__((device_builtin)) double __dsqrt_ru(double x);
# 387 "/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)) 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);
extern __attribute__((device)) __attribute__((device_builtin)) double __rcp64h(double);


}
# 415 "/usr/local/cuda/include/sm_20_intrinsics.h"
static __inline__ __attribute__((device)) 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);







# 1 "/usr/local/cuda/include/sm_20_intrinsics.hpp" 1
# 67 "/usr/local/cuda/include/sm_20_intrinsics.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/sm_20_intrinsics.hpp" 2
# 77 "/usr/local/cuda/include/sm_20_intrinsics.hpp"
static __inline__ __attribute__((device)) unsigned int ballot(bool pred)
{
  return __ballot((int)pred);
}

static __inline__ __attribute__((device)) int syncthreads_count(bool pred)
{
  return __syncthreads_count((int)pred);
}

static __inline__ __attribute__((device)) bool syncthreads_and(bool pred)
{
  return (bool)__syncthreads_and((int)pred);
}

static __inline__ __attribute__((device)) bool syncthreads_or(bool pred)
{
  return (bool)__syncthreads_or((int)pred);
}




static __inline__ __attribute__((device)) unsigned int __isGlobal(const void *ptr)
{
    unsigned int ret;
    asm volatile ("{ \n\t"
                  "    .reg .pred p; \n\t"
                  "    isspacep.global p, %1; \n\t"
                  "    selp.u32 %0, 1, 0, p;  \n\t"

                  "} \n\t" : "=r"(ret) : "l"(ptr));




    return ret;
}
# 434 "/usr/local/cuda/include/sm_20_intrinsics.h" 2
# 4192 "/usr/local/cuda/include/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
# 91 "/usr/local/cuda/include/sm_30_intrinsics.h"
static __attribute__((device)) __inline__ int __shfl(int var, int srcLane, int width=32);

static __attribute__((device)) __inline__ unsigned int __shfl(unsigned int var, int srcLane, int width=32);

static __attribute__((device)) __inline__ int __shfl_up(int var, unsigned int delta, int width=32);
static __attribute__((device)) __inline__ unsigned int __shfl_up(unsigned int var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ int __shfl_down(int var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ unsigned int __shfl_down(unsigned int var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ int __shfl_xor(int var, int laneMask, int width=32);

static __attribute__((device)) __inline__ unsigned int __shfl_xor(unsigned int var, int laneMask, int width=32);

static __attribute__((device)) __inline__ float __shfl(float var, int srcLane, int width=32);

static __attribute__((device)) __inline__ float __shfl_up(float var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ float __shfl_down(float var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ float __shfl_xor(float var, int laneMask, int width=32);


static __attribute__((device)) __inline__ long long __shfl(long long var, int srcLane, int width=32);

static __attribute__((device)) __inline__ unsigned long long __shfl(unsigned long long var, int srcLane, int width=32);

static __attribute__((device)) __inline__ long long __shfl_up(long long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ long long __shfl_down(long long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ long long __shfl_xor(long long var, int laneMask, int width=32);

static __attribute__((device)) __inline__ unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width=32);

static __attribute__((device)) __inline__ double __shfl(double var, int srcLane, int width=32);

static __attribute__((device)) __inline__ double __shfl_up(double var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ double __shfl_down(double var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ double __shfl_xor(double var, int laneMask, int width=32);



static __attribute__((device)) __inline__ long __shfl(long var, int srcLane, int width=32);

static __attribute__((device)) __inline__ unsigned long __shfl(unsigned long var, int srcLane, int width=32);

static __attribute__((device)) __inline__ long __shfl_up(long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ unsigned long __shfl_up(unsigned long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ long __shfl_down(long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ unsigned long __shfl_down(unsigned long var, unsigned int delta, int width=32);

static __attribute__((device)) __inline__ long __shfl_xor(long var, int laneMask, int width=32);

static __attribute__((device)) __inline__ unsigned long __shfl_xor(unsigned long var, int laneMask, int width=32);
# 169 "/usr/local/cuda/include/sm_30_intrinsics.h"
# 1 "/usr/local/cuda/include/sm_30_intrinsics.hpp" 1
# 69 "/usr/local/cuda/include/sm_30_intrinsics.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 70 "/usr/local/cuda/include/sm_30_intrinsics.hpp" 2





extern "C"
{


}
# 99 "/usr/local/cuda/include/sm_30_intrinsics.hpp"
static __attribute__((device)) __inline__ int __shfl(int var, int srcLane, int width) {
 int ret;
 int c = ((32 -width) << 8) | 0x1f;
 asm volatile ("shfl.idx.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(srcLane), "r"(c));
 return ret;
}

static __attribute__((device)) __inline__ unsigned int __shfl(unsigned int var, int srcLane, int width) {
 return (unsigned int) __shfl((int)var, srcLane, width);
}

static __attribute__((device)) __inline__ int __shfl_up(int var, unsigned int delta, int width) {
 int ret;
 int c = (32 -width) << 8;
 asm volatile ("shfl.up.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(delta), "r"(c));
 return ret;
}
static __attribute__((device)) __inline__ unsigned int __shfl_up(unsigned int var, unsigned int delta, int width) {
 return (unsigned int) __shfl_up((int)var, delta, width);
}

static __attribute__((device)) __inline__ int __shfl_down(int var, unsigned int delta, int width) {
 int ret;
 int c = ((32 -width) << 8) | 0x1f;
 asm volatile ("shfl.down.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(delta), "r"(c));
 return ret;
}

static __attribute__((device)) __inline__ unsigned int __shfl_down(unsigned int var, unsigned int delta, int width) {
 return (unsigned int) __shfl_down((int)var, delta, width);
}

static __attribute__((device)) __inline__ int __shfl_xor(int var, int laneMask, int width) {
 int ret;
 int c = ((32 -width) << 8) | 0x1f;
 asm volatile ("shfl.bfly.b32 %0, %1, %2, %3;" : "=r"(ret) : "r"(var), "r"(laneMask), "r"(c));
 return ret;
}

static __attribute__((device)) __inline__ unsigned int __shfl_xor(unsigned int var, int laneMask, int width) {
 return (unsigned int) __shfl_xor((int)var, laneMask, width);
}

static __attribute__((device)) __inline__ float __shfl(float var, int srcLane, int width) {
 float ret;
    int c;
 c = ((32 -width) << 8) | 0x1f;
 asm volatile ("shfl.idx.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(srcLane), "r"(c));
 return ret;
}

static __attribute__((device)) __inline__ float __shfl_up(float var, unsigned int delta, int width) {
 float ret;
    int c;
 c = (32 -width) << 8;
 asm volatile ("shfl.up.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(delta), "r"(c));
 return ret;
}

static __attribute__((device)) __inline__ float __shfl_down(float var, unsigned int delta, int width) {
 float ret;
    int c;
 c = ((32 -width) << 8) | 0x1f;
 asm volatile ("shfl.down.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(delta), "r"(c));
 return ret;
}

static __attribute__((device)) __inline__ float __shfl_xor(float var, int laneMask, int width) {
 float ret;
    int c;
 c = ((32 -width) << 8) | 0x1f;
 asm volatile ("shfl.bfly.b32 %0, %1, %2, %3;" : "=f"(ret) : "f"(var), "r"(laneMask), "r"(c));
 return ret;
}


static __attribute__((device)) __inline__ long long __shfl(long long var, int srcLane, int width) {
 int lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var));
 hi = __shfl(hi, srcLane, width);
 lo = __shfl(lo, srcLane, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi));
 return var;
}

static __attribute__((device)) __inline__ unsigned long long __shfl(unsigned long long var, int srcLane, int width) {
 return (unsigned long long) __shfl((long long) var, srcLane, width);
}

static __attribute__((device)) __inline__ long long __shfl_up(long long var, unsigned int delta, int width) {
 int lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var));
 hi = __shfl_up(hi, delta, width);
 lo = __shfl_up(lo, delta, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi));
 return var;
}

static __attribute__((device)) __inline__ unsigned long long __shfl_up(unsigned long long var, unsigned int delta, int width) {
 return (unsigned long long) __shfl_up((long long) var, delta, width);
}

static __attribute__((device)) __inline__ long long __shfl_down(long long var, unsigned int delta, int width) {
 int lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var));
 hi = __shfl_down(hi, delta, width);
 lo = __shfl_down(lo, delta, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi));
 return var;
}

static __attribute__((device)) __inline__ unsigned long long __shfl_down(unsigned long long var, unsigned int delta, int width) {
 return (unsigned long long) __shfl_down((long long) var, delta, width);
}

static __attribute__((device)) __inline__ long long __shfl_xor(long long var, int laneMask, int width) {
 int lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=r"(lo), "=r"(hi) : "l"(var));
 hi = __shfl_xor(hi, laneMask, width);
 lo = __shfl_xor(lo, laneMask, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=l"(var) : "r"(lo), "r"(hi));
 return var;
}

static __attribute__((device)) __inline__ unsigned long long __shfl_xor(unsigned long long var, int laneMask, int width) {
 return (unsigned long long) __shfl_xor((long long) var, laneMask, width);
}

static __attribute__((device)) __inline__ double __shfl(double var, int srcLane, int width) {
 float lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=f"(lo), "=f"(hi) : "d"(var));
 hi = __shfl(hi, srcLane, width);
 lo = __shfl(lo, srcLane, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "f"(lo), "f"(hi));
 return var;
}

static __attribute__((device)) __inline__ double __shfl_up(double var, unsigned int delta, int width) {
 float lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=f"(lo), "=f"(hi) : "d"(var));
 hi = __shfl_up(hi, delta, width);
 lo = __shfl_up(lo, delta, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "f"(lo), "f"(hi));
 return var;
}

static __attribute__((device)) __inline__ double __shfl_down(double var, unsigned int delta, int width) {
 float lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=f"(lo), "=f"(hi) : "d"(var));
 hi = __shfl_down(hi, delta, width);
 lo = __shfl_down(lo, delta, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "f"(lo), "f"(hi));
 return var;
}

static __attribute__((device)) __inline__ double __shfl_xor(double var, int laneMask, int width) {
 float lo, hi;
 asm volatile("mov.b64 {%0,%1}, %2;" : "=f"(lo), "=f"(hi) : "d"(var));
 hi = __shfl_xor(hi, laneMask, width);
 lo = __shfl_xor(lo, laneMask, width);
 asm volatile("mov.b64 %0, {%1,%2};" : "=d"(var) : "f"(lo), "f"(hi));
 return var;
}



static __attribute__((device)) __inline__ long __shfl(long var, int srcLane, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl((long long) var, srcLane, width) :
  __shfl((int) var, srcLane, width);
}

static __attribute__((device)) __inline__ unsigned long __shfl(unsigned long var, int srcLane, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl((unsigned long long) var, srcLane, width) :
  __shfl((unsigned int) var, srcLane, width);
}

static __attribute__((device)) __inline__ long __shfl_up(long var, unsigned int delta, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl_up((long long) var, delta, width) :
  __shfl_up((int) var, delta, width);
}

static __attribute__((device)) __inline__ unsigned long __shfl_up(unsigned long var, unsigned int delta, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl_up((unsigned long long) var, delta, width) :
  __shfl_up((unsigned int) var, delta, width);
}

static __attribute__((device)) __inline__ long __shfl_down(long var, unsigned int delta, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl_down((long long) var, delta, width) :
  __shfl_down((int) var, delta, width);
}

static __attribute__((device)) __inline__ unsigned long __shfl_down(unsigned long var, unsigned int delta, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl_down((unsigned long long) var, delta, width) :
  __shfl_down((unsigned int) var, delta, width);
}

static __attribute__((device)) __inline__ long __shfl_xor(long var, int laneMask, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl_xor((long long) var, laneMask, width) :
  __shfl_xor((int) var, laneMask, width);
}

static __attribute__((device)) __inline__ unsigned long __shfl_xor(unsigned long var, int laneMask, int width) {
 return (sizeof(long) == sizeof(long long)) ?
  __shfl_xor((unsigned long long) var, laneMask, width) :
  __shfl_xor((unsigned int) var, laneMask, width);
}
# 170 "/usr/local/cuda/include/sm_30_intrinsics.h" 2
# 4193 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_32_intrinsics.h" 1
# 134 "/usr/local/cuda/include/sm_32_intrinsics.h"
# 1 "/usr/local/cuda/include/sm_32_intrinsics.hpp" 1
# 135 "/usr/local/cuda/include/sm_32_intrinsics.h" 2
# 4194 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/sm_35_intrinsics.h" 1
# 4195 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/surface_functions.h" 1
# 67 "/usr/local/cuda/include/surface_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/surface_functions.h" 2
# 79 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) uchar1 __surf1Dreadc1(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar2 __surf1Dreadc2(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar4 __surf1Dreadc4(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort1 __surf1Dreads1(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort2 __surf1Dreads2(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort4 __surf1Dreads4(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint1 __surf1Dreadu1(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint2 __surf1Dreadu2(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __surf1Dreadu4(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong1 __surf1Dreadl1(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong2 __surf1Dreadl2(surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
# 105 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dread(T *res, surface<void, 0x01> surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf1Dreadc1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc1(surf, x, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf1Dreads1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads1(surf, x, cudaBoundaryModeClamp) : __surf1Dreads1(surf, x, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu2(surf, x, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu4(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu4(surf, x, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surf1Dread(&tmp, surf, x, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dread(T *res, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surf1Dread<T>(surf, x, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf1Dreadc1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf1Dreadc1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadc1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf1Dreadc1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc1(surf, x, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadc1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc1(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadc2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc2(surf, x, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadc2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc2(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadc4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc4(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc4(surf, x, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadc4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadc4(surf, x, cudaBoundaryModeClamp) : __surf1Dreadc4(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf1Dreads1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads1(surf, x, cudaBoundaryModeClamp) : __surf1Dreads1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreads1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads1(surf, x, cudaBoundaryModeClamp) : __surf1Dreads1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf1Dreads1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads1(surf, x, cudaBoundaryModeClamp) : __surf1Dreads1(surf, x, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreads1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads1(surf, x, cudaBoundaryModeClamp) : __surf1Dreads1(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreads2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads2(surf, x, cudaBoundaryModeClamp) : __surf1Dreads2(surf, x, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreads2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads2(surf, x, cudaBoundaryModeClamp) : __surf1Dreads2(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreads4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads4(surf, x, cudaBoundaryModeClamp) : __surf1Dreads4(surf, x, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreads4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreads4(surf, x, cudaBoundaryModeClamp) : __surf1Dreads4(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu2(surf, x, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadu2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu2(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu4(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu4(surf, x, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadu4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu4(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu4(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf1Dreadl1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadl1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadl1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadl1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadl1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadl1(surf, x, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf1Dreadl1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadl1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadl1(surf, x, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadl1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadl1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadl1(surf, x, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadl2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadl2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadl2(surf, x, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1Dreadl2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadl2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadl2(surf, x, cudaBoundaryModeTrap ));
}
# 392 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf1Dreadu1(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu1(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu1(surf, x, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu2(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu2(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu2(surf, x, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surf1Dread(surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1Dreadu4(surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dreadu4(surf, x, cudaBoundaryModeClamp) : __surf1Dreadu4(surf, x, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 427 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) uchar1 __surf2Dreadc1(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar2 __surf2Dreadc2(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar4 __surf2Dreadc4(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort1 __surf2Dreads1(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort2 __surf2Dreads2(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort4 __surf2Dreads4(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint1 __surf2Dreadu1(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint2 __surf2Dreadu2(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __surf2Dreadu4(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong1 __surf2Dreadl1(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong2 __surf2Dreadl2(surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
# 453 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dread(T *res, surface<void, 0x02> surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc1(surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads1(surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu2(surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu4(surf, x, y, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surf2Dread(&tmp, surf, x, y, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dread(T *res, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surf2Dread<T>(surf, x, y, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc1(surf, x, y, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc1(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadc2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc2(surf, x, y, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadc2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc2(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadc4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc4(surf, x, y, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadc4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadc4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadc4(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads1(surf, x, y, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads1(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreads2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads2(surf, x, y, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreads2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads2(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreads4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads4(surf, x, y, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreads4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreads4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreads4(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu2(surf, x, y, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu2(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu4(surf, x, y, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu4(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadl1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadl1(surf, x, y, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadl1(surf, x, y, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadl1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadl1(surf, x, y, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadl2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadl2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadl2(surf, x, y, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2Dreadl2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadl2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadl2(surf, x, y, cudaBoundaryModeTrap ));
}
# 740 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu1(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu1(surf, x, y, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu2(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu2(surf, x, y, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surf2Dread(surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dreadu4(surf, x, y, cudaBoundaryModeClamp) : __surf2Dreadu4(surf, x, y, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 775 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) uchar1 __surf3Dreadc1(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar2 __surf3Dreadc2(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar4 __surf3Dreadc4(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort1 __surf3Dreads1(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort2 __surf3Dreads2(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort4 __surf3Dreads4(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint1 __surf3Dreadu1(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint2 __surf3Dreadu2(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __surf3Dreadu4(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong1 __surf3Dreadl1(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong2 __surf3Dreadl2(surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
# 801 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dread(T *res, surface<void, 0x03> surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads1(surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surf3Dread(&tmp, surf, x, y, z, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dread(T *res, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surf3Dread<T>(surf, x, y, z, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc1(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadc2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc2(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadc2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc2(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadc4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc4(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadc4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadc4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadc4(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads1(surf, x, y, z, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads1(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreads2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads2(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreads2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads2(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreads4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads4(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreads4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreads4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreads4(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadl1(surf, x, y, z, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadl2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadl2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadl2(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf3Dreadl2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadl2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadl2(surf, x, y, z, cudaBoundaryModeTrap ));
}
# 1088 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu1(surf, x, y, z, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu2(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surf3Dread(surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dreadu4(surf, x, y, z, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 1123 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) uchar1 __surf1DLayeredreadc1(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar2 __surf1DLayeredreadc2(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uchar4 __surf1DLayeredreadc4(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort1 __surf1DLayeredreads1(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort2 __surf1DLayeredreads2(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ushort4 __surf1DLayeredreads4(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint1 __surf1DLayeredreadu1(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint2 __surf1DLayeredreadu2(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __surf1DLayeredreadu4(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong1 __surf1DLayeredreadl1(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong2 __surf1DLayeredreadl2(surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
# 1149 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredread(T *res, surface<void, 0xF1> surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surf1DLayeredread(&tmp, surf, x, layer, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredread(T *res, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surf1DLayeredread<T>(surf, x, layer, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc1(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc2(surf, x, layer, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc2(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc4(surf, x, layer, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadc4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadc4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadc4(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads1(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads2(surf, x, layer, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads2(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads4(surf, x, layer, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreads4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreads4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreads4(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadl1(surf, x, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadl2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadl2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadl2(surf, x, layer, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadl2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadl2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadl2(surf, x, layer, cudaBoundaryModeTrap ));
}
# 1436 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu1(surf, x, layer, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu2(surf, x, layer, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surf1DLayeredread(surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredreadu4(surf, x, layer, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 1471 "/usr/local/cuda/include/surface_functions.h"
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uchar1 __surf2DLayeredreadc1(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uchar2 __surf2DLayeredreadc2(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uchar4 __surf2DLayeredreadc4(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) ushort1 __surf2DLayeredreads1(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) ushort2 __surf2DLayeredreads2(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) ushort4 __surf2DLayeredreads4(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint1 __surf2DLayeredreadu1(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint2 __surf2DLayeredreadu2(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __surf2DLayeredreadu4(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong1 __surf2DLayeredreadl1(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) ulonglong2 __surf2DLayeredreadl2(T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
# 1508 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredread(T *res, surface<void, 0xF2> surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surf2DLayeredread(&tmp, surf, x, y, layer, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredread(T *res, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surf2DLayeredread<T>(surf, x, y, layer, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc2(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc2(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc4(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadc4(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads2(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads2(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads4(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreads4(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layer, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadl2(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadl2(surf, x, y, layer, cudaBoundaryModeTrap ));
}
# 1795 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layer, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surf2DLayeredread(surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layer, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 1844 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapread(T *res, surface<void, 0x0C> surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surfCubemapread(&tmp, surf, x, y, face, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapread(T *res, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surfCubemapread<T>(surf, x, y, face, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc2(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc2(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc4(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadc4(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads2(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads2(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads4(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreads4(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, face, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadl2(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadl2(surf, x, y, face, cudaBoundaryModeTrap ));
}
# 2131 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, face, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surfCubemapread(surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, face, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 2181 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredread(T *res, surface<void, 0xFC> surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  (s == 1) ? (void)(*(uchar1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(*(ushort1*)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(*(uint1 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(*(uint2 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(*(uint4 *)res = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) T surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  T tmp;

  surfCubemapLayeredread(&tmp, surf, x, y, layerFace, (int)sizeof(T), mode);

  return tmp;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredread(T *res, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  *res = surfCubemapLayeredread<T>(surf, x, y, layerFace, mode);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return (char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) signed char surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return (signed char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return make_char1((signed char)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc1(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  uchar2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc2(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_char2((signed char)tmp.x, (signed char)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc2(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) char4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  uchar4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc4(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_char4((signed char)tmp.x, (signed char)tmp.y, (signed char)tmp.z, (signed char)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadc4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadc4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadc4(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return (short)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return make_short1((signed short)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads1(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ushort2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads2(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_short2((signed short)tmp.x, (signed short)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads2(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) short4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ushort4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads4(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_short4((signed short)tmp.x, (signed short)tmp.y, (signed short)tmp.z, (signed short)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreads4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreads4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreads4(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return (int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return make_int1((signed int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_int2((int)tmp.x, (int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) int4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_int4((int)tmp.x, (int)tmp.y, (int)tmp.z, (int)tmp.w);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) uint4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) long long int surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return (long long int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) unsigned long long int surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x;
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return make_longlong1((long long int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadl1(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) longlong2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ulonglong2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadl2(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_longlong2((long long int)tmp.x, (long long int)tmp.y);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) ulonglong2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadl2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadl2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadl2(surf, x, y, layerFace, cudaBoundaryModeTrap ));
}
# 2468 "/usr/local/cuda/include/surface_functions.h"
template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return __int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x);
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float1 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  return make_float1(__int_as_float((int)((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu1(surf, x, y, layerFace, cudaBoundaryModeTrap )).x));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float2 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  uint2 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu2(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_float2(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y));
}

template<>
__inline__ __attribute__((always_inline)) __attribute__((device)) float4 surfCubemapLayeredread(surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  uint4 tmp = ((mode == cudaBoundaryModeZero) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredreadu4(surf, x, y, layerFace, cudaBoundaryModeTrap ));

  return make_float4(__int_as_float((int)tmp.x), __int_as_float((int)tmp.y), __int_as_float((int)tmp.z), __int_as_float((int)tmp.w));
}
# 2504 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwritec1( uchar1 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwritec2( uchar2 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwritec4( uchar4 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwrites1( ushort1 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwrites2( ushort2 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwrites4( ushort4 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwriteu1( uint1 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwriteu2( uint2 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwriteu4( uint4 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwritel1(ulonglong1 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1Dwritel2(ulonglong2 val, surface<void, 0x01> t, int x, enum cudaSurfaceBoundaryMode mode);
# 2530 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(T val, surface<void, 0x01> surf, int x, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1Dwritec1(tmp.c1, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec1(tmp.c1, surf, x, cudaBoundaryModeClamp) : __surf1Dwritec1(tmp.c1, surf, x, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1Dwrites1(tmp.s1, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites1(tmp.s1, surf, x, cudaBoundaryModeClamp) : __surf1Dwrites1(tmp.s1, surf, x, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(tmp.u1, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(tmp.u1, surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(tmp.u1, surf, x, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1Dwriteu2(tmp.u2, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu2(tmp.u2, surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu2(tmp.u2, surf, x, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1Dwriteu4(tmp.u4, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu4(tmp.u4, surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu4(tmp.u4, surf, x, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(T val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{;
  surf1Dwrite(val, surf, x, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(signed char val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned char val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uchar1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uchar2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uchar4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned short val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ushort1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ushort2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ushort4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uint1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uint2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uint4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(long long int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned long long int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(longlong1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ulonglong1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(longlong2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ulonglong2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 2641 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 2657 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwritec1( uchar1 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwritec2( uchar2 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwritec4( uchar4 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwrites1( ushort1 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwrites2( ushort2 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwrites4( ushort4 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwriteu1( uint1 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwriteu2( uint2 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwriteu4( uint4 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwritel1(ulonglong1 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2Dwritel2(ulonglong2 val, surface<void, 0x02> t, int x, int y, enum cudaSurfaceBoundaryMode mode);
# 2683 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(T val, surface<void, 0x02> surf, int x, int y, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2Dwritec1(tmp.c1, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec1(tmp.c1, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec1(tmp.c1, surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2Dwrites1(tmp.s1, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites1(tmp.s1, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites1(tmp.s1, surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(tmp.u1, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(tmp.u1, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(tmp.u1, surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2Dwriteu2(tmp.u2, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu2(tmp.u2, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu2(tmp.u2, surf, x, y, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2Dwriteu4(tmp.u4, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu4(tmp.u4, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu4(tmp.u4, surf, x, y, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(T val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{;
  surf2Dwrite(val, surf, x, y, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(signed char val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned char val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uchar1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uchar2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uchar4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned short val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ushort1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ushort2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ushort4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uint1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uint2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uint4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(long long int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned long long int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(longlong1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ulonglong1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(longlong2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ulonglong2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 2794 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 2810 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwritec1( uchar1 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwritec2( uchar2 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwritec4( uchar4 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwrites1( ushort1 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwrites2( ushort2 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwrites4( ushort4 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwriteu1( uint1 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwriteu2( uint2 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwriteu4( uint4 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwritel1(ulonglong1 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf3Dwritel2(ulonglong2 val, surface<void, 0x03> t, int x, int y, int z, enum cudaSurfaceBoundaryMode mode);
# 2836 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(T val, surface<void, 0x03> surf, int x, int y, int z, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf3Dwritec1(tmp.c1, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec1(tmp.c1, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec1(tmp.c1, surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf3Dwrites1(tmp.s1, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites1(tmp.s1, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites1(tmp.s1, surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(tmp.u1, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(tmp.u1, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(tmp.u1, surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf3Dwriteu2(tmp.u2, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu2(tmp.u2, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu2(tmp.u2, surf, x, y, z, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf3Dwriteu4(tmp.u4, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu4(tmp.u4, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu4(tmp.u4, surf, x, y, z, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(T val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{;
  surf3Dwrite(val, surf, x, y, z, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(signed char val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned char val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uchar1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uchar2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uchar4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned short val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ushort1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ushort2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ushort4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uint1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uint2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uint4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(long long int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned long long int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(longlong1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ulonglong1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(longlong2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ulonglong2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 2947 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 2963 "/usr/local/cuda/include/surface_functions.h"
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwritec1( uchar1 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwritec2( uchar2 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwritec4( uchar4 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwrites1( ushort1 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwrites2( ushort2 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwrites4( ushort4 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwriteu1( uint1 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwriteu2( uint2 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwriteu4( uint4 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwritel1(ulonglong1 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
extern __attribute__((device)) __attribute__((device_builtin)) void __surf1DLayeredwritel2(ulonglong2 val, surface<void, 0xF1> t, int x, int layer, enum cudaSurfaceBoundaryMode mode);
# 2989 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(T val, surface<void, 0xF1> surf, int x, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec1(tmp.c1, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec1(tmp.c1, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec1(tmp.c1, surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites1(tmp.s1, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites1(tmp.s1, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites1(tmp.s1, surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(tmp.u1, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(tmp.u1, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(tmp.u1, surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu2(tmp.u2, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu2(tmp.u2, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu2(tmp.u2, surf, x, layer, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu4(tmp.u4, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu4(tmp.u4, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu4(tmp.u4, surf, x, layer, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(T val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{;
  surf1DLayeredwrite(val, surf, x, layer, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(signed char val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned char val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uchar1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uchar2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uchar4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned short val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ushort1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ushort2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ushort4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uint1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uint2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uint4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(long long int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned long long int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(longlong1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ulonglong1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(longlong2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ulonglong2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3100 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3116 "/usr/local/cuda/include/surface_functions.h"
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwritec1( uchar1 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwritec2( uchar2 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwritec4( uchar4 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwrites1( ushort1 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwrites2( ushort2 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwrites4( ushort4 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwriteu1( uint1 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwriteu2( uint2 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwriteu4( uint4 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwritel1(ulonglong1 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
template <typename T>
extern __attribute__((device)) __attribute__((device_builtin)) void __surf2DLayeredwritel2(ulonglong2 val, T t, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode);
# 3153 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(T val, surface<void, 0xF2> surf, int x, int y, int layer, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(tmp.c1, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(tmp.c1, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(tmp.c1, surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(tmp.s1, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(tmp.s1, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(tmp.s1, surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(tmp.u1, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(tmp.u1, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(tmp.u1, surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(tmp.u2, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(tmp.u2, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(tmp.u2, surf, x, y, layer, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(tmp.u4, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(tmp.u4, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(tmp.u4, surf, x, y, layer, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(T val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{;
  surf2DLayeredwrite(val, surf, x, y, layer, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(signed char val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned char val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uchar1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uchar2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uchar4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned short val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ushort1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ushort2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ushort4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uint1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uint2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uint4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(long long int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned long long int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(longlong1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ulonglong1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(longlong2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ulonglong2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3264 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3295 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(T val, surface<void, 0x0C> surf, int x, int y, int face, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(tmp.c1, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(tmp.c1, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(tmp.c1, surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(tmp.s1, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(tmp.s1, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(tmp.s1, surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(tmp.u1, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(tmp.u1, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(tmp.u1, surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(tmp.u2, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(tmp.u2, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(tmp.u2, surf, x, y, face, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(tmp.u4, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(tmp.u4, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(tmp.u4, surf, x, y, face, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(T val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  surfCubemapwrite(val, surf, x, y, face, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(signed char val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned char val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uchar1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uchar2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uchar4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned short val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ushort1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ushort2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ushort4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uint1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uint2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uint4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(long long int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned long long int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(longlong1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ulonglong1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(longlong2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ulonglong2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3406 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3437 "/usr/local/cuda/include/surface_functions.h"
template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(T val, surface<void, 0xFC> surf, int x, int y, int layerFace, int s, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{
  union {
    T val;
    uchar1 c1;
    ushort1 s1;
    uint1 u1;
    uint2 u2;
    uint4 u4;
  } tmp;

  tmp.val = val;

  (s == 1) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(tmp.c1, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(tmp.c1, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(tmp.c1, surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 2) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(tmp.s1, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(tmp.s1, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(tmp.s1, surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 4) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(tmp.u1, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(tmp.u1, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(tmp.u1, surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 8) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(tmp.u2, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(tmp.u2, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(tmp.u2, surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
  (s == 16) ? (void)(((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(tmp.u4, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(tmp.u4, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(tmp.u4, surf, x, y, layerFace, cudaBoundaryModeTrap ))) :
              (void)0;
}

template<class T>
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(T val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap)
{;
  surfCubemapLayeredwrite(val, surf, x, y, layerFace, (int)sizeof(T), mode);
}


static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(signed char val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned char val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uchar1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uchar2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uchar4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned short val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ushort1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ushort2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ushort4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uint1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uint2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uint4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(long long int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned long long int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(longlong1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ulonglong1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(longlong2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ulonglong2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3548 "/usr/local/cuda/include/surface_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode = cudaBoundaryModeTrap);
# 3681 "/usr/local/cuda/include/surface_functions.h"
# 1 "/usr/local/cuda/include/surface_functions.hpp" 1
# 67 "/usr/local/cuda/include/surface_functions.hpp"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/surface_functions.hpp" 2
# 94 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec1(make_uchar1((unsigned char)val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec1(make_uchar1((unsigned char)val), surf, x, cudaBoundaryModeClamp) : __surf1Dwritec1(make_uchar1((unsigned char)val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(signed char val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec1(make_uchar1((unsigned char)val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec1(make_uchar1((unsigned char)val), surf, x, cudaBoundaryModeClamp) : __surf1Dwritec1(make_uchar1((unsigned char)val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned char val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec1(make_uchar1(val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec1(make_uchar1(val), surf, x, cudaBoundaryModeClamp) : __surf1Dwritec1(make_uchar1(val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec1(make_uchar1((unsigned char)val.x), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec1(make_uchar1((unsigned char)val.x), surf, x, cudaBoundaryModeClamp) : __surf1Dwritec1(make_uchar1((unsigned char)val.x), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uchar1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec1(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec1(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwritec1(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, cudaBoundaryModeClamp) : __surf1Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uchar2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec2(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec2(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwritec2(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(char4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, cudaBoundaryModeClamp) : __surf1Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uchar4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritec4(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritec4(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwritec4(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites1(make_ushort1((unsigned short)val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites1(make_ushort1((unsigned short)val), surf, x, cudaBoundaryModeClamp) : __surf1Dwrites1(make_ushort1((unsigned short)val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned short val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites1(make_ushort1(val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites1(make_ushort1(val), surf, x, cudaBoundaryModeClamp) : __surf1Dwrites1(make_ushort1(val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites1(make_ushort1((unsigned short)val.x), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites1(make_ushort1((unsigned short)val.x), surf, x, cudaBoundaryModeClamp) : __surf1Dwrites1(make_ushort1((unsigned short)val.x), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ushort1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites1(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites1(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwrites1(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, cudaBoundaryModeClamp) : __surf1Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ushort2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites2(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites2(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwrites2(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(short4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, cudaBoundaryModeClamp) : __surf1Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ushort4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwrites4(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwrites4(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwrites4(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(make_uint1((unsigned int)val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(make_uint1((unsigned int)val), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(make_uint1((unsigned int)val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(make_uint1(val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(make_uint1(val), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(make_uint1(val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(make_uint1((unsigned int)val.x), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(make_uint1((unsigned int)val.x), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(make_uint1((unsigned int)val.x), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uint1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uint2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu2(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu2(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu2(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(int4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(uint4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu4(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu4(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu4(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(long long int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, cudaBoundaryModeClamp) : __surf1Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(unsigned long long int val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritel1(make_ulonglong1(val), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritel1(make_ulonglong1(val), surf, x, cudaBoundaryModeClamp) : __surf1Dwritel1(make_ulonglong1(val), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(longlong1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, cudaBoundaryModeClamp) : __surf1Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ulonglong1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritel1(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritel1(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwritel1(val, surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(longlong2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, cudaBoundaryModeClamp) : __surf1Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(ulonglong2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwritel2(val, surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwritel2(val, surf, x, cudaBoundaryModeClamp) : __surf1Dwritel2(val, surf, x, cudaBoundaryModeTrap ));
}
# 293 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float1 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float2 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1Dwrite(float4 val, surface<void, 0x01> surf, int x, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, cudaBoundaryModeClamp) : __surf1Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, cudaBoundaryModeTrap ));
}
# 336 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec1(make_uchar1((unsigned char)val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec1(make_uchar1((unsigned char)val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec1(make_uchar1((unsigned char)val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(signed char val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec1(make_uchar1((unsigned char)val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec1(make_uchar1((unsigned char)val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec1(make_uchar1((unsigned char)val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned char val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec1(make_uchar1(val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec1(make_uchar1(val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec1(make_uchar1(val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec1(make_uchar1((unsigned char)val.x), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec1(make_uchar1((unsigned char)val.x), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec1(make_uchar1((unsigned char)val.x), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uchar1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec1(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec1(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec1(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uchar2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec2(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec2(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec2(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(char4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uchar4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritec4(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritec4(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritec4(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites1(make_ushort1((unsigned short)val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites1(make_ushort1((unsigned short)val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites1(make_ushort1((unsigned short)val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned short val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites1(make_ushort1(val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites1(make_ushort1(val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites1(make_ushort1(val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites1(make_ushort1((unsigned short)val.x), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites1(make_ushort1((unsigned short)val.x), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites1(make_ushort1((unsigned short)val.x), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ushort1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites1(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites1(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites1(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ushort2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites2(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites2(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites2(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(short4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ushort4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwrites4(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwrites4(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwrites4(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(make_uint1((unsigned int)val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(make_uint1((unsigned int)val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(make_uint1((unsigned int)val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(make_uint1(val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(make_uint1(val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(make_uint1(val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(make_uint1((unsigned int)val.x), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(make_uint1((unsigned int)val.x), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(make_uint1((unsigned int)val.x), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uint1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uint2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu2(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu2(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu2(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(int4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(uint4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu4(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu4(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu4(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(long long int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(unsigned long long int val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritel1(make_ulonglong1(val), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritel1(make_ulonglong1(val), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritel1(make_ulonglong1(val), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(longlong1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ulonglong1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritel1(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritel1(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritel1(val, surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(longlong2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(ulonglong2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwritel2(val, surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwritel2(val, surf, x, y, cudaBoundaryModeClamp) : __surf2Dwritel2(val, surf, x, y, cudaBoundaryModeTrap ));
}
# 535 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float1 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float2 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2Dwrite(float4 val, surface<void, 0x02> surf, int x, int y, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, cudaBoundaryModeClamp) : __surf2Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, cudaBoundaryModeTrap ));
}
# 578 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec1(make_uchar1((unsigned char)val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec1(make_uchar1((unsigned char)val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec1(make_uchar1((unsigned char)val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(signed char val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec1(make_uchar1((unsigned char)val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec1(make_uchar1((unsigned char)val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec1(make_uchar1((unsigned char)val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned char val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec1(make_uchar1(val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec1(make_uchar1(val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec1(make_uchar1(val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec1(make_uchar1((unsigned char)val.x), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec1(make_uchar1((unsigned char)val.x), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec1(make_uchar1((unsigned char)val.x), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uchar1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec1(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec1(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec1(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uchar2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec2(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec2(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec2(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(char4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uchar4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritec4(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritec4(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritec4(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites1(make_ushort1((unsigned short)val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites1(make_ushort1((unsigned short)val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites1(make_ushort1((unsigned short)val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned short val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites1(make_ushort1(val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites1(make_ushort1(val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites1(make_ushort1(val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites1(make_ushort1((unsigned short)val.x), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites1(make_ushort1((unsigned short)val.x), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites1(make_ushort1((unsigned short)val.x), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ushort1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites1(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites1(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites1(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ushort2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites2(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites2(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites2(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(short4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ushort4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwrites4(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwrites4(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwrites4(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(make_uint1((unsigned int)val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(make_uint1((unsigned int)val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(make_uint1((unsigned int)val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(make_uint1(val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(make_uint1(val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(make_uint1(val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(make_uint1((unsigned int)val.x), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(make_uint1((unsigned int)val.x), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(make_uint1((unsigned int)val.x), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uint1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uint2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu2(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu2(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu2(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(int4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(uint4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu4(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu4(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu4(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(long long int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(unsigned long long int val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritel1(make_ulonglong1(val), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritel1(make_ulonglong1(val), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritel1(make_ulonglong1(val), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(longlong1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ulonglong1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritel1(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritel1(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritel1(val, surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(longlong2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(ulonglong2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwritel2(val, surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwritel2(val, surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwritel2(val, surf, x, y, z, cudaBoundaryModeTrap ));
}
# 777 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float1 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float2 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, z, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf3Dwrite(float4 val, surface<void, 0x03> surf, int x, int y, int z, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf3Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, z, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf3Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, z, cudaBoundaryModeClamp) : __surf3Dwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, z, cudaBoundaryModeTrap ));
}
# 820 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(signed char val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned char val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec1(make_uchar1(val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec1(make_uchar1(val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec1(make_uchar1(val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uchar1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec1(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec1(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec1(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uchar2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec2(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec2(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec2(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(char4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uchar4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritec4(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritec4(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritec4(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned short val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites1(make_ushort1(val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites1(make_ushort1(val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites1(make_ushort1(val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ushort1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites1(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites1(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites1(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ushort2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites2(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites2(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites2(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(short4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ushort4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwrites4(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwrites4(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwrites4(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(make_uint1(val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(make_uint1(val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(make_uint1(val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uint1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uint2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu2(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu2(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu2(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(int4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(uint4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu4(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu4(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu4(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(long long int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(unsigned long long int val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritel1(make_ulonglong1(val), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritel1(make_ulonglong1(val), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritel1(make_ulonglong1(val), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(longlong1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ulonglong1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritel1(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritel1(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritel1(val, surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(longlong2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(ulonglong2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwritel2(val, surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwritel2(val, surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwritel2(val, surf, x, layer, cudaBoundaryModeTrap ));
}
# 1019 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float1 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float2 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf1DLayeredwrite(float4 val, surface<void, 0xF1> surf, int x, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf1DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf1DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, layer, cudaBoundaryModeClamp) : __surf1DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, layer, cudaBoundaryModeTrap ));
}
# 1062 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(signed char val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned char val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uchar1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uchar2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec2(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec2(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec2(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(char4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uchar4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec4(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec4(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritec4(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned short val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ushort1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ushort2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites2(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites2(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites2(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(short4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ushort4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites4(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites4(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwrites4(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uint1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uint2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(int4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(uint4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(long long int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(unsigned long long int val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(longlong1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ulonglong1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(longlong2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(ulonglong2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel2(val, surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel2(val, surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwritel2(val, surf, x, y, layer, cudaBoundaryModeTrap ));
}
# 1261 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float1 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float2 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, layer, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surf2DLayeredwrite(float4 val, surface<void, 0xF2> surf, int x, int y, int layer, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layer, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layer, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layer, cudaBoundaryModeTrap ));
}
# 1305 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(signed char val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned char val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uchar1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uchar2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec2(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec2(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec2(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(char4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uchar4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec4(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec4(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritec4(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned short val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ushort1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ushort2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites2(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites2(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites2(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(short4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ushort4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites4(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites4(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwrites4(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uint1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uint2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(int4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(uint4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(long long int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(unsigned long long int val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(longlong1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ulonglong1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(val, surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(longlong2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(ulonglong2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel2(val, surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel2(val, surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwritel2(val, surf, x, y, face, cudaBoundaryModeTrap ));
}
# 1504 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float1 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float2 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, face, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapwrite(float4 val, surface<void, 0x0C> surf, int x, int y, int face, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, face, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, face, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, face, cudaBoundaryModeTrap ));
}
# 1548 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(signed char val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned char val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1(val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(make_uchar1((unsigned char)val.x), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uchar1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec1(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec1(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec1(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec2(make_uchar2((unsigned char)val.x, (unsigned char)val.y), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uchar2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec2(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec2(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec2(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(char4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec4(make_uchar4((unsigned char)val.x, (unsigned char)val.y, (unsigned char)val.z, (unsigned char)val.w), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uchar4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritec4(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritec4(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritec4(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1((unsigned short)val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned short val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1(val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(make_ushort1((unsigned short)val.x), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ushort1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites1(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites1(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites1(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites2(make_ushort2((unsigned short)val.x, (unsigned short)val.y), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ushort2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites2(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites2(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites2(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(short4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites4(make_ushort4((unsigned short)val.x, (unsigned short)val.y, (unsigned short)val.z, (unsigned short)val.w), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ushort4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwrites4(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwrites4(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwrites4(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1(val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)val.x), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uint1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(make_uint2((unsigned int)val.x, (unsigned int)val.y), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uint2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(int4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(make_uint4((unsigned int)val.x, (unsigned int)val.y, (unsigned int)val.z, (unsigned int)val.w), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(uint4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(long long int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(unsigned long long int val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1(val), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(longlong1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(make_ulonglong1((unsigned long long int)val.x), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ulonglong1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel1(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel1(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritel1(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(longlong2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritel2(make_ulonglong2((unsigned long long int)val.x, (unsigned long long int)val.y), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(ulonglong2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwritel2(val, surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwritel2(val, surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwritel2(val, surf, x, y, layerFace, cudaBoundaryModeTrap ));
}
# 1747 "/usr/local/cuda/include/surface_functions.hpp"
static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val)), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float1 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu1(make_uint1((unsigned int)__float_as_int(val.x)), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float2 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu2(make_uint2((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y)), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) void surfCubemapLayeredwrite(float4 val, surface<void, 0xFC> surf, int x, int y, int layerFace, enum cudaSurfaceBoundaryMode mode)
{
  ((mode == cudaBoundaryModeZero) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layerFace, cudaBoundaryModeZero ) : (mode == cudaBoundaryModeClamp) ? __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layerFace, cudaBoundaryModeClamp) : __surf2DLayeredwriteu4(make_uint4((unsigned int)__float_as_int(val.x), (unsigned int)__float_as_int(val.y), (unsigned int)__float_as_int(val.z), (unsigned int)__float_as_int(val.w)), surf, x, y, layerFace, cudaBoundaryModeTrap ));
}
# 3682 "/usr/local/cuda/include/surface_functions.h" 2
# 4196 "/usr/local/cuda/include/device_functions.h" 2
# 1 "/usr/local/cuda/include/texture_fetch_functions.h" 1
# 67 "/usr/local/cuda/include/texture_fetch_functions.h"
# 1 "/usr/local/cuda/include/builtin_types.h" 1
# 68 "/usr/local/cuda/include/texture_fetch_functions.h" 2
# 80 "/usr/local/cuda/include/texture_fetch_functions.h"
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchi1D(T, int4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchi1D(T, int4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchi1D(T, int4);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetch1D(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetch2D(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetch3D(T, float4);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetch1D(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetch2D(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetch3D(T, float4);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetch1D(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetch2D(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetch3D(T, float4);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchcube(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchcube(T, float4);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchcube(T, float4);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchl1D(T, float4, int);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchl2D(T, float4, int);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchl1D(T, float4, int);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchl2D(T, float4, int);

template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchl1D(T, float4, int);
template <class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchl2D(T, float4, int);


template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlcube(T, float4, int);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlcube(T, float4, int);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlcube(T, float4, int);


template<class T, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchi(texture<T, 0x01, readMode> t, int4 i)
{
  return __utexfetchi1D(t, i);
}

template<class T, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchi(texture<T, 0x01, readMode> t, int4 i)
{
  return __itexfetchi1D(t, i);
}

template<class T, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchi(texture<T, 0x01, readMode> t, int4 i)
{
  return __ftexfetchi1D(t, i);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetch(texture<T, texType, readMode> t, float4 i, int d = texType)
{
  switch(d) {
  case 1: return __utexfetch1D(t, i);
  case 2: return __utexfetch2D(t, i);

  default: return __utexfetch3D(t, i);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetch(texture<T, texType, readMode> t, float4 i, int d = texType)
{
  switch(d) {
  case 1: return __itexfetch1D(t, i);
  case 2: return __itexfetch2D(t, i);

  default: return __itexfetch3D(t, i);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetch(texture<T, texType, readMode> t, float4 i, int d = texType)
{
  switch(d) {
  case 1: return __ftexfetch1D(t, i);
  case 2: return __ftexfetch2D(t, i);

  default: return __ftexfetch3D(t, i);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchc(texture<T, texType, readMode> t, float4 i)
{
  return __utexfetchcube(t, i);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchc(texture<T, texType, readMode> t, float4 i)
{
  return __itexfetchcube(t, i);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchc(texture<T, texType, readMode> t, float4 i)
{
  return __ftexfetchcube(t, i);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchl(texture<T, texType, readMode> t, float4 i, int l, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __utexfetchl1D(t, i, l);

  default: return __utexfetchl2D(t, i, l);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchl(texture<T, texType, readMode> t, float4 i, int l, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __itexfetchl1D(t, i, l);

  default: return __itexfetchl2D(t, i, l);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchl(texture<T, texType, readMode> t, float4 i, int l, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __ftexfetchl1D(t, i, l);

  default: return __ftexfetchl2D(t, i, l);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchlc(texture<T, texType, readMode> t, float4 i, int l)
{
  return __utexfetchlcube(t, i, l);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchlc(texture<T, texType, readMode> t, float4 i, int l)
{
  return __itexfetchlcube(t, i, l);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchlc(texture<T, texType, readMode> t, float4 i, int l)
{
  return __ftexfetchlcube(t, i, l);
}
# 280 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex1Dfetch(texture<char, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex1Dfetch(texture<signed char, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex1Dfetch(texture<unsigned char, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex1Dfetch(texture<char1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex1Dfetch(texture<uchar1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex1Dfetch(texture<char2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex1Dfetch(texture<uchar2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex1Dfetch(texture<char4, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex1Dfetch(texture<uchar4, 0x01, cudaReadModeElementType> t, int x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex1Dfetch(texture<short, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex1Dfetch(texture<unsigned short, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex1Dfetch(texture<short1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex1Dfetch(texture<ushort1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex1Dfetch(texture<short2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex1Dfetch(texture<ushort2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex1Dfetch(texture<short4, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex1Dfetch(texture<ushort4, 0x01, cudaReadModeElementType> t, int x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex1Dfetch(texture<int, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex1Dfetch(texture<unsigned int, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex1Dfetch(texture<int1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex1Dfetch(texture<uint1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex1Dfetch(texture<int2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex1Dfetch(texture<uint2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex1Dfetch(texture<int4, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex1Dfetch(texture<uint4, 0x01, cudaReadModeElementType> t, int x);
# 374 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1Dfetch(texture<float, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1Dfetch(texture<float1, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1Dfetch(texture<float2, 0x01, cudaReadModeElementType> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1Dfetch(texture<float4, 0x01, cudaReadModeElementType> t, int x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1Dfetch(texture<char, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1Dfetch(texture<signed char, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1Dfetch(texture<unsigned char, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1Dfetch(texture<char1, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1Dfetch(texture<uchar1, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1Dfetch(texture<char2, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1Dfetch(texture<uchar2, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1Dfetch(texture<char4, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1Dfetch(texture<uchar4, 0x01, cudaReadModeNormalizedFloat> t, int x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1Dfetch(texture<short, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1Dfetch(texture<unsigned short, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1Dfetch(texture<short1, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1Dfetch(texture<ushort1, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1Dfetch(texture<short2, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1Dfetch(texture<ushort2, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1Dfetch(texture<short4, 0x01, cudaReadModeNormalizedFloat> t, int x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1Dfetch(texture<ushort4, 0x01, cudaReadModeNormalizedFloat> t, int x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex1D(texture<char, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex1D(texture<signed char, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex1D(texture<unsigned char, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex1D(texture<char1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex1D(texture<uchar1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex1D(texture<char2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex1D(texture<uchar2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex1D(texture<char4, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex1D(texture<uchar4, 0x01, cudaReadModeElementType> t, float x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex1D(texture<short, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex1D(texture<unsigned short, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex1D(texture<short1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex1D(texture<ushort1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex1D(texture<short2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex1D(texture<ushort2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex1D(texture<short4, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex1D(texture<ushort4, 0x01, cudaReadModeElementType> t, float x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex1D(texture<int, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex1D(texture<unsigned int, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex1D(texture<int1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex1D(texture<uint1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex1D(texture<int2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex1D(texture<uint2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex1D(texture<int4, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex1D(texture<uint4, 0x01, cudaReadModeElementType> t, float x);
# 534 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1D(texture<float, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1D(texture<float1, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1D(texture<float2, 0x01, cudaReadModeElementType> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1D(texture<float4, 0x01, cudaReadModeElementType> t, float x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1D(texture<char, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1D(texture<signed char, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1D(texture<unsigned char, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1D(texture<char1, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1D(texture<uchar1, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1D(texture<char2, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1D(texture<uchar2, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1D(texture<char4, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1D(texture<uchar4, 0x01, cudaReadModeNormalizedFloat> t, float x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1D(texture<short, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1D(texture<unsigned short, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1D(texture<short1, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1D(texture<ushort1, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1D(texture<short2, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1D(texture<ushort2, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1D(texture<short4, 0x01, cudaReadModeNormalizedFloat> t, float x);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1D(texture<ushort4, 0x01, cudaReadModeNormalizedFloat> t, float x);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex2D(texture<char, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex2D(texture<signed char, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex2D(texture<unsigned char, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex2D(texture<char1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex2D(texture<uchar1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex2D(texture<char2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex2D(texture<uchar2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2D(texture<char4, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2D(texture<uchar4, 0x02, cudaReadModeElementType> t, float x, float y);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex2D(texture<short, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex2D(texture<unsigned short, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex2D(texture<short1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex2D(texture<ushort1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex2D(texture<short2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex2D(texture<ushort2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2D(texture<short4, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2D(texture<ushort4, 0x02, cudaReadModeElementType> t, float x, float y);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex2D(texture<int, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex2D(texture<unsigned int, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex2D(texture<int1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex2D(texture<uint1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex2D(texture<int2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex2D(texture<uint2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2D(texture<int4, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2D(texture<uint4, 0x02, cudaReadModeElementType> t, float x, float y);
# 688 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2D(texture<float, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2D(texture<float1, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2D(texture<float2, 0x02, cudaReadModeElementType> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2D(texture<float4, 0x02, cudaReadModeElementType> t, float x, float y);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2D(texture<char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2D(texture<signed char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2D(texture<unsigned char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2D(texture<char1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2D(texture<uchar1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2D(texture<char2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2D(texture<uchar2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2D(texture<char4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2D(texture<uchar4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2D(texture<short, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2D(texture<unsigned short, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2D(texture<short1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2D(texture<ushort1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2D(texture<short2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2D(texture<ushort2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2D(texture<short4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2D(texture<ushort4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex1DLayered(texture<char, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex1DLayered(texture<signed char, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex1DLayered(texture<unsigned char, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex1DLayered(texture<char1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex1DLayered(texture<uchar1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex1DLayered(texture<char2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex1DLayered(texture<uchar2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex1DLayered(texture<char4, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex1DLayered(texture<uchar4, 0xF1, cudaReadModeElementType> t, float x, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex1DLayered(texture<short, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex1DLayered(texture<unsigned short, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex1DLayered(texture<short1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex1DLayered(texture<ushort1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex1DLayered(texture<short2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex1DLayered(texture<ushort2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex1DLayered(texture<short4, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex1DLayered(texture<ushort4, 0xF1, cudaReadModeElementType> t, float x, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex1DLayered(texture<int, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex1DLayered(texture<unsigned int, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex1DLayered(texture<int1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex1DLayered(texture<uint1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex1DLayered(texture<int2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex1DLayered(texture<uint2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex1DLayered(texture<int4, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex1DLayered(texture<uint4, 0xF1, cudaReadModeElementType> t, float x, int layer);
# 842 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayered(texture<float, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayered(texture<float1, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayered(texture<float2, 0xF1, cudaReadModeElementType> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayered(texture<float4, 0xF1, cudaReadModeElementType> t, float x, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayered(texture<char, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayered(texture<signed char, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayered(texture<unsigned char, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayered(texture<char1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayered(texture<uchar1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayered(texture<char2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayered(texture<uchar2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayered(texture<char4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayered(texture<uchar4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayered(texture<short, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayered(texture<unsigned short, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayered(texture<short1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayered(texture<ushort1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayered(texture<short2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayered(texture<ushort2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayered(texture<short4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayered(texture<ushort4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex2DLayered(texture<char, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex2DLayered(texture<signed char, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex2DLayered(texture<unsigned char, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex2DLayered(texture<char1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex2DLayered(texture<uchar1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex2DLayered(texture<char2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex2DLayered(texture<uchar2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2DLayered(texture<char4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2DLayered(texture<uchar4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex2DLayered(texture<short, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex2DLayered(texture<unsigned short, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex2DLayered(texture<short1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex2DLayered(texture<ushort1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex2DLayered(texture<short2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex2DLayered(texture<ushort2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2DLayered(texture<short4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2DLayered(texture<ushort4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex2DLayered(texture<int, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex2DLayered(texture<unsigned int, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex2DLayered(texture<int1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex2DLayered(texture<uint1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex2DLayered(texture<int2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex2DLayered(texture<uint2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2DLayered(texture<int4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2DLayered(texture<uint4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);
# 996 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayered(texture<float, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayered(texture<float1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayered(texture<float2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayered(texture<float4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayered(texture<char, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayered(texture<signed char, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayered(texture<unsigned char, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayered(texture<char1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayered(texture<uchar1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayered(texture<char2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayered(texture<uchar2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayered(texture<char4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayered(texture<uchar4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayered(texture<short, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayered(texture<unsigned short, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayered(texture<short1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayered(texture<ushort1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayered(texture<short2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayered(texture<ushort2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayered(texture<short4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayered(texture<ushort4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex3D(texture<char, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex3D(texture<signed char, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex3D(texture<unsigned char, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex3D(texture<char1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex3D(texture<uchar1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex3D(texture<char2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex3D(texture<uchar2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex3D(texture<char4, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex3D(texture<uchar4, 0x03, cudaReadModeElementType> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex3D(texture<short, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex3D(texture<unsigned short, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex3D(texture<short1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex3D(texture<ushort1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex3D(texture<short2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex3D(texture<ushort2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex3D(texture<short4, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex3D(texture<ushort4, 0x03, cudaReadModeElementType> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex3D(texture<int, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex3D(texture<unsigned int, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex3D(texture<int1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex3D(texture<uint1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex3D(texture<int2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex3D(texture<uint2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex3D(texture<int4, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex3D(texture<uint4, 0x03, cudaReadModeElementType> t, float x, float y, float z);
# 1150 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3D(texture<float, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3D(texture<float1, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3D(texture<float2, 0x03, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3D(texture<float4, 0x03, cudaReadModeElementType> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3D(texture<char, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3D(texture<signed char, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3D(texture<unsigned char, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3D(texture<char1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3D(texture<uchar1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3D(texture<char2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3D(texture<uchar2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3D(texture<char4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3D(texture<uchar4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3D(texture<short, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3D(texture<unsigned short, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3D(texture<short1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3D(texture<ushort1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3D(texture<short2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3D(texture<ushort2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3D(texture<short4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3D(texture<ushort4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char texCubemap(texture<char, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char texCubemap(texture<signed char, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char texCubemap(texture<unsigned char, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 texCubemap(texture<char1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 texCubemap(texture<uchar1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 texCubemap(texture<char2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 texCubemap(texture<uchar2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 texCubemap(texture<char4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 texCubemap(texture<uchar4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short texCubemap(texture<short, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short texCubemap(texture<unsigned short, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 texCubemap(texture<short1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 texCubemap(texture<ushort1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 texCubemap(texture<short2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 texCubemap(texture<ushort2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 texCubemap(texture<short4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 texCubemap(texture<ushort4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int texCubemap(texture<int, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int texCubemap(texture<unsigned int, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 texCubemap(texture<int1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 texCubemap(texture<uint1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 texCubemap(texture<int2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 texCubemap(texture<uint2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 texCubemap(texture<int4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 texCubemap(texture<uint4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);
# 1304 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemap(texture<float, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemap(texture<float1, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemap(texture<float2, 0x0C, cudaReadModeElementType> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemap(texture<float4, 0x0C, cudaReadModeElementType> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemap(texture<char, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemap(texture<signed char, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemap(texture<unsigned char, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemap(texture<char1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemap(texture<uchar1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemap(texture<char2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemap(texture<uchar2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemap(texture<char4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemap(texture<uchar4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemap(texture<short, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemap(texture<unsigned short, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemap(texture<short1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemap(texture<ushort1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemap(texture<short2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemap(texture<ushort2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemap(texture<short4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemap(texture<ushort4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char texCubemapLayered(texture<char, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char texCubemapLayered(texture<signed char, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char texCubemapLayered(texture<unsigned char, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 texCubemapLayered(texture<char1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 texCubemapLayered(texture<uchar1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 texCubemapLayered(texture<char2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 texCubemapLayered(texture<uchar2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 texCubemapLayered(texture<char4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 texCubemapLayered(texture<uchar4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short texCubemapLayered(texture<short, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short texCubemapLayered(texture<unsigned short, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 texCubemapLayered(texture<short1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 texCubemapLayered(texture<ushort1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 texCubemapLayered(texture<short2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 texCubemapLayered(texture<ushort2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 texCubemapLayered(texture<short4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 texCubemapLayered(texture<ushort4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int texCubemapLayered(texture<int, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int texCubemapLayered(texture<unsigned int, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 texCubemapLayered(texture<int1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 texCubemapLayered(texture<uint1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 texCubemapLayered(texture<int2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 texCubemapLayered(texture<uint2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 texCubemapLayered(texture<int4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 texCubemapLayered(texture<uint4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);
# 1458 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayered(texture<float, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayered(texture<float1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayered(texture<float2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayered(texture<float4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayered(texture<char, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayered(texture<signed char, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayered(texture<unsigned char, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayered(texture<char1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayered(texture<uchar1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayered(texture<char2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayered(texture<uchar2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayered(texture<char4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayered(texture<uchar4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayered(texture<short, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayered(texture<unsigned short, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayered(texture<short1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayered(texture<ushort1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayered(texture<short2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayered(texture<ushort2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayered(texture<short4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayered(texture<ushort4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer);
# 1551 "/usr/local/cuda/include/texture_fetch_functions.h"
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itex2Dgather0(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itex2Dgather1(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itex2Dgather2(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itex2Dgather3(T, float2);


template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utex2Dgather0(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utex2Dgather1(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utex2Dgather2(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utex2Dgather3(T, float2);


template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftex2Dgather0(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftex2Dgather1(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftex2Dgather2(T, float2);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftex2Dgather3(T, float2);


template<int comp, class T, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itex2Dgather(texture<T, 0x02, readMode> t, float2 i,
                    int c=comp)
{
  switch (c) {
  case 0: return __itex2Dgather0(t, i);
  case 1: return __itex2Dgather1(t, i);
  case 2: return __itex2Dgather2(t, i);

  default: return __itex2Dgather3(t, i);
  }
}

template<int comp, class T, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utex2Dgather(texture<T, 0x02, readMode> t, float2 i,
                     int c=comp)
{
  switch (c) {
  case 0: return __utex2Dgather0(t, i);
  case 1: return __utex2Dgather1(t, i);
  case 2: return __utex2Dgather2(t, i);

  default: return __utex2Dgather3(t, i);
  }
}

template<int comp, class T, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftex2Dgather(texture<T, 0x02, readMode> t, float2 i,
                      int c=comp)
{
  switch (c) {
  case 0: return __ftex2Dgather0(t, i);
  case 1: return __ftex2Dgather1(t, i);
  case 2: return __ftex2Dgather2(t, i);

  default: return __ftex2Dgather3(t, i);
  }
}

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2Dgather(texture<char, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2Dgather(texture<signed char, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2Dgather(texture<unsigned char, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2Dgather(texture<char1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2Dgather(texture<uchar1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2Dgather(texture<char2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2Dgather(texture<uchar2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2Dgather(texture<char3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2Dgather(texture<uchar3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2Dgather(texture<char4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2Dgather(texture<uchar4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2Dgather(texture<signed short, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2Dgather(texture<unsigned short, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2Dgather(texture<short1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2Dgather(texture<ushort1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2Dgather(texture<short2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2Dgather(texture<ushort2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2Dgather(texture<short3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2Dgather(texture<ushort3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2Dgather(texture<short4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2Dgather(texture<ushort4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2Dgather(texture<signed int, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2Dgather(texture<unsigned int, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2Dgather(texture<int1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2Dgather(texture<uint1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2Dgather(texture<int2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2Dgather(texture<uint2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2Dgather(texture<int3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2Dgather(texture<uint3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2Dgather(texture<int4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2Dgather(texture<uint4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<float, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<float1, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<float2, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<float3, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<float4, 0x02, cudaReadModeElementType> t, float x, float y, int comp = 0);
# 1702 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<signed char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<unsigned char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<char1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<uchar1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<char2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<uchar2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<char3, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<uchar3, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<char4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<uchar4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<signed short, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<unsigned short, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<short1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<ushort1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<short2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<ushort2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<short3, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<ushort3, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<short4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2Dgather(texture<ushort4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, int comp = 0);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlod1D(T, float4, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlod2D(T, float4, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlod3D(T, float4, float);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlod1D(T, float4, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlod2D(T, float4, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlod3D(T, float4, float);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlod1D(T, float4, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlod2D(T, float4, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlod3D(T, float4, float);


template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlodcube(T, float4, float);
template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlodcube(T, float4, float);
template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlodcube(T, float4, float);

template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlodl1D(T, float4, int, float);
template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlodl2D(T, float4, int, float);

template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlodl1D(T, float4, int, float);
template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlodl2D(T, float4, int, float);

template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlodl1D(T, float4, int, float);
template<class T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlodl2D(T, float4, int, float);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchlodlcube(T, float4, int, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchlodlcube(T, float4, int, float);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchlodlcube(T, float4, int, float);


template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchgrad1D(T, float4, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchgrad2D(T, float4, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchgrad3D(T, float4, float4, float4);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchgrad1D(T, float4, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchgrad2D(T, float4, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchgrad3D(T, float4, float4, float4);


template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchgrad1D(T, float4, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchgrad2D(T, float4, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchgrad3D(T, float4, float4, float4);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchgradl1D(T, float4, int, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) uint4 __utexfetchgradl2D(T, float4, int, float4, float4);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchgradl1D(T, float4, int, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) int4 __itexfetchgradl2D(T, float4, int, float4, float4);

template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchgradl1D(T, float4, int, float4, float4);
template<typename T>
extern __attribute__((device)) __attribute__((device_builtin)) float4 __ftexfetchgradl2D(T, float4, int, float4, float4);


template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchlod(texture<T, texType, readMode> t, float4 i, float level,
                     int d = texType)
{
  switch (d) {
  case 1: return __utexfetchlod1D(t, i, level);
  case 2: return __utexfetchlod2D(t, i, level);

  default: return __utexfetchlod3D(t, i, level);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchlod(texture<T, texType, readMode> t, float4 i, float level,
                    int d = texType)
{
  switch (d) {
  case 1: return __itexfetchlod1D(t, i, level);
  case 2: return __itexfetchlod2D(t, i, level);

  default: return __itexfetchlod3D(t, i, level);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchlod(texture<T, texType, readMode> t, float4 i, float level,
                      int d = texType)
{
  switch (d) {
  case 1: return __ftexfetchlod1D(t, i, level);
  case 2: return __ftexfetchlod2D(t, i, level);

  default: return __ftexfetchlod3D(t, i, level);
  }
}


template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchlodc(texture<T, texType, readMode> t, float4 i, float level)
{
  return __utexfetchlodcube(t, i, level);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchlodc(texture<T, texType, readMode> t, float4 i, float level)
{
  return __itexfetchlodcube(t, i, level);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchlodc(texture<T, texType, readMode> t, float4 i, float level)
{
  return __ftexfetchlodcube(t, i, level);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchlodl(texture<T, texType, readMode> t, float4 i, int l,
                      float level, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __utexfetchlodl1D(t, i, l, level);

  default: return __utexfetchlodl2D(t, i, l, level);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchlodl(texture<T, texType, readMode> t, float4 i, int l,
                     float level, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __itexfetchlodl1D(t, i, l, level);

  default: return __itexfetchlodl2D(t, i, l, level);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchlodl(texture<T, texType, readMode> t, float4 i, int l,
                       float level, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __ftexfetchlodl1D(t, i, l, level);

  default: return __ftexfetchlodl2D(t, i, l, level);
  }
}


template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchlodlc(texture<T, texType, readMode> t, float4 i, int l,
                       float level)
{
  return __utexfetchlodlcube(t, i, l, level);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchlodlc(texture<T, texType, readMode> t, float4 i, int l,
                      float level)
{
  return __itexfetchlodlcube(t, i, l, level);
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchlodlc(texture<T, texType, readMode> t, float4 i, int l,
                        float level)
{
  return __ftexfetchlodlcube(t, i, l, level);
}
# 1963 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex1DLod(texture<char, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex1DLod(texture<signed char, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex1DLod(texture<unsigned char, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex1DLod(texture<char1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex1DLod(texture<uchar1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex1DLod(texture<char2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex1DLod(texture<uchar2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex1DLod(texture<char4, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex1DLod(texture<uchar4, 0x01, cudaReadModeElementType> t, float x, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex1DLod(texture<short, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex1DLod(texture<unsigned short, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex1DLod(texture<short1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex1DLod(texture<ushort1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex1DLod(texture<short2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex1DLod(texture<ushort2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex1DLod(texture<short4, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex1DLod(texture<ushort4, 0x01, cudaReadModeElementType> t, float x, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex1DLod(texture<int, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex1DLod(texture<unsigned int, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex1DLod(texture<int1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex1DLod(texture<uint1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex1DLod(texture<int2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex1DLod(texture<uint2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex1DLod(texture<int4, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex1DLod(texture<uint4, 0x01, cudaReadModeElementType> t, float x, float level);
# 2063 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLod(texture<float, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLod(texture<float1, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLod(texture<float2, 0x01, cudaReadModeElementType> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLod(texture<float4, 0x01, cudaReadModeElementType> t, float x, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLod(texture<char, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLod(texture<signed char, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLod(texture<unsigned char, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLod(texture<char1, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLod(texture<uchar1, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLod(texture<char2, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLod(texture<uchar2, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLod(texture<char4, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLod(texture<uchar4, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLod(texture<short, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLod(texture<unsigned short, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLod(texture<short1, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLod(texture<ushort1, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLod(texture<short2, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLod(texture<ushort2, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLod(texture<short4, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLod(texture<ushort4, 0x01, cudaReadModeNormalizedFloat> t, float x, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex2DLod(texture<char, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex2DLod(texture<signed char, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex2DLod(texture<unsigned char, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex2DLod(texture<char1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex2DLod(texture<uchar1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex2DLod(texture<char2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex2DLod(texture<uchar2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2DLod(texture<char4, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2DLod(texture<uchar4, 0x02, cudaReadModeElementType> t, float x, float y, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex2DLod(texture<short, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex2DLod(texture<unsigned short, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex2DLod(texture<short1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex2DLod(texture<ushort1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex2DLod(texture<short2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex2DLod(texture<ushort2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2DLod(texture<short4, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2DLod(texture<ushort4, 0x02, cudaReadModeElementType> t, float x, float y, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex2DLod(texture<int, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex2DLod(texture<unsigned int, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex2DLod(texture<int1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex2DLod(texture<uint1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex2DLod(texture<int2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex2DLod(texture<uint2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2DLod(texture<int4, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2DLod(texture<uint4, 0x02, cudaReadModeElementType> t, float x, float y, float level);
# 2217 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLod(texture<float, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLod(texture<float1, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLod(texture<float2, 0x02, cudaReadModeElementType> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLod(texture<float4, 0x02, cudaReadModeElementType> t, float x, float y, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLod(texture<char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLod(texture<signed char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLod(texture<unsigned char, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLod(texture<char1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLod(texture<uchar1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLod(texture<char2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLod(texture<uchar2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLod(texture<char4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLod(texture<uchar4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLod(texture<short, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLod(texture<unsigned short, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLod(texture<short1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLod(texture<ushort1, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLod(texture<short2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLod(texture<ushort2, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLod(texture<short4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLod(texture<ushort4, 0x02, cudaReadModeNormalizedFloat> t, float x, float y, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex1DLayeredLod(texture<char, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex1DLayeredLod(texture<signed char, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex1DLayeredLod(texture<unsigned char, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex1DLayeredLod(texture<char1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex1DLayeredLod(texture<uchar1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex1DLayeredLod(texture<char2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex1DLayeredLod(texture<uchar2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex1DLayeredLod(texture<char4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex1DLayeredLod(texture<uchar4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex1DLayeredLod(texture<short, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex1DLayeredLod(texture<unsigned short, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex1DLayeredLod(texture<short1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex1DLayeredLod(texture<ushort1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex1DLayeredLod(texture<short2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex1DLayeredLod(texture<ushort2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex1DLayeredLod(texture<short4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex1DLayeredLod(texture<ushort4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex1DLayeredLod(texture<int, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex1DLayeredLod(texture<unsigned int, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex1DLayeredLod(texture<int1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex1DLayeredLod(texture<uint1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex1DLayeredLod(texture<int2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex1DLayeredLod(texture<uint2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex1DLayeredLod(texture<int4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex1DLayeredLod(texture<uint4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);
# 2371 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayeredLod(texture<float, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayeredLod(texture<float1, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayeredLod(texture<float2, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayeredLod(texture<float4, 0xF1, cudaReadModeElementType> t, float x, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayeredLod(texture<char, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayeredLod(texture<signed char, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayeredLod(texture<unsigned char, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayeredLod(texture<char1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayeredLod(texture<uchar1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayeredLod(texture<char2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayeredLod(texture<uchar2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayeredLod(texture<char4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayeredLod(texture<uchar4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayeredLod(texture<short, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DLayeredLod(texture<unsigned short, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayeredLod(texture<short1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DLayeredLod(texture<ushort1, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayeredLod(texture<short2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DLayeredLod(texture<ushort2, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayeredLod(texture<short4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DLayeredLod(texture<ushort4, 0xF1, cudaReadModeNormalizedFloat> t, float x, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex2DLayeredLod(texture<char, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex2DLayeredLod(texture<signed char, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex2DLayeredLod(texture<unsigned char, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex2DLayeredLod(texture<char1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex2DLayeredLod(texture<uchar1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex2DLayeredLod(texture<char2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex2DLayeredLod(texture<uchar2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2DLayeredLod(texture<char4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2DLayeredLod(texture<uchar4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex2DLayeredLod(texture<short, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex2DLayeredLod(texture<unsigned short, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex2DLayeredLod(texture<short1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex2DLayeredLod(texture<ushort1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex2DLayeredLod(texture<short2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex2DLayeredLod(texture<ushort2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex2DLayeredLod(texture<short4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex2DLayeredLod(texture<ushort4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex2DLayeredLod(texture<int, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex2DLayeredLod(texture<unsigned int, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex2DLayeredLod(texture<int1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex2DLayeredLod(texture<uint1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex2DLayeredLod(texture<int2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex2DLayeredLod(texture<uint2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex2DLayeredLod(texture<int4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex2DLayeredLod(texture<uint4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);
# 2525 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayeredLod(texture<float, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayeredLod(texture<float1, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayeredLod(texture<float2, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayeredLod(texture<float4, 0xF2, cudaReadModeElementType> t, float x, float y, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayeredLod(texture<char, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayeredLod(texture<signed char, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayeredLod(texture<unsigned char, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayeredLod(texture<char1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayeredLod(texture<uchar1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayeredLod(texture<char2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayeredLod(texture<uchar2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayeredLod(texture<char4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayeredLod(texture<uchar4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayeredLod(texture<short, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex2DLayeredLod(texture<unsigned short, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayeredLod(texture<short1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex2DLayeredLod(texture<ushort1, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayeredLod(texture<short2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex2DLayeredLod(texture<ushort2, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayeredLod(texture<short4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex2DLayeredLod(texture<ushort4, 0xF2, cudaReadModeNormalizedFloat> t, float x, float y, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex3DLod(texture<char, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex3DLod(texture<signed char, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex3DLod(texture<unsigned char, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex3DLod(texture<char1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex3DLod(texture<uchar1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex3DLod(texture<char2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex3DLod(texture<uchar2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex3DLod(texture<char4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex3DLod(texture<uchar4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex3DLod(texture<short, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex3DLod(texture<unsigned short, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex3DLod(texture<short1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex3DLod(texture<ushort1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex3DLod(texture<short2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex3DLod(texture<ushort2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex3DLod(texture<short4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex3DLod(texture<ushort4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex3DLod(texture<int, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex3DLod(texture<unsigned int, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex3DLod(texture<int1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex3DLod(texture<uint1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex3DLod(texture<int2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex3DLod(texture<uint2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex3DLod(texture<int4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex3DLod(texture<uint4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);
# 2679 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3DLod(texture<float, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3DLod(texture<float1, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3DLod(texture<float2, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3DLod(texture<float4, 0x03, cudaReadModeElementType> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3DLod(texture<char, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3DLod(texture<signed char, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3DLod(texture<unsigned char, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3DLod(texture<char1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3DLod(texture<uchar1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3DLod(texture<char2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3DLod(texture<uchar2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3DLod(texture<char4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3DLod(texture<uchar4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3DLod(texture<short, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex3DLod(texture<unsigned short, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3DLod(texture<short1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex3DLod(texture<ushort1, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3DLod(texture<short2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex3DLod(texture<ushort2, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3DLod(texture<short4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex3DLod(texture<ushort4, 0x03, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char texCubemapLod(texture<char, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char texCubemapLod(texture<signed char, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char texCubemapLod(texture<unsigned char, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 texCubemapLod(texture<char1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 texCubemapLod(texture<uchar1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 texCubemapLod(texture<char2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 texCubemapLod(texture<uchar2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 texCubemapLod(texture<char4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 texCubemapLod(texture<uchar4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short texCubemapLod(texture<short, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short texCubemapLod(texture<unsigned short, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 texCubemapLod(texture<short1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 texCubemapLod(texture<ushort1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 texCubemapLod(texture<short2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 texCubemapLod(texture<ushort2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 texCubemapLod(texture<short4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 texCubemapLod(texture<ushort4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int texCubemapLod(texture<int, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int texCubemapLod(texture<unsigned int, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 texCubemapLod(texture<int1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 texCubemapLod(texture<uint1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 texCubemapLod(texture<int2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 texCubemapLod(texture<uint2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 texCubemapLod(texture<int4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 texCubemapLod(texture<uint4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);
# 2833 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLod(texture<float, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLod(texture<float1, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLod(texture<float2, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLod(texture<float4, 0x0C, cudaReadModeElementType> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLod(texture<char, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLod(texture<signed char, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLod(texture<unsigned char, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLod(texture<char1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLod(texture<uchar1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLod(texture<char2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLod(texture<uchar2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLod(texture<char4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLod(texture<uchar4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLod(texture<short, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLod(texture<unsigned short, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLod(texture<short1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLod(texture<ushort1, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLod(texture<short2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLod(texture<ushort2, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLod(texture<short4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLod(texture<ushort4, 0x0C, cudaReadModeNormalizedFloat> t, float x, float y, float z, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char texCubemapLayeredLod(texture<char, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char texCubemapLayeredLod(texture<signed char, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char texCubemapLayeredLod(texture<unsigned char, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 texCubemapLayeredLod(texture<char1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 texCubemapLayeredLod(texture<uchar1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 texCubemapLayeredLod(texture<char2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 texCubemapLayeredLod(texture<uchar2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 texCubemapLayeredLod(texture<char4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 texCubemapLayeredLod(texture<uchar4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short texCubemapLayeredLod(texture<short, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short texCubemapLayeredLod(texture<unsigned short, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 texCubemapLayeredLod(texture<short1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 texCubemapLayeredLod(texture<ushort1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 texCubemapLayeredLod(texture<short2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 texCubemapLayeredLod(texture<ushort2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 texCubemapLayeredLod(texture<short4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 texCubemapLayeredLod(texture<ushort4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int texCubemapLayeredLod(texture<int, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int texCubemapLayeredLod(texture<unsigned int, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 texCubemapLayeredLod(texture<int1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 texCubemapLayeredLod(texture<uint1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 texCubemapLayeredLod(texture<int2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 texCubemapLayeredLod(texture<uint2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 texCubemapLayeredLod(texture<int4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 texCubemapLayeredLod(texture<uint4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);
# 2987 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayeredLod(texture<float, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayeredLod(texture<float1, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayeredLod(texture<float2, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayeredLod(texture<float4, 0xFC, cudaReadModeElementType> t, float x, float y, float z, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayeredLod(texture<char, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayeredLod(texture<signed char, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayeredLod(texture<unsigned char, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayeredLod(texture<char1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayeredLod(texture<uchar1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayeredLod(texture<char2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayeredLod(texture<uchar2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayeredLod(texture<char4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayeredLod(texture<uchar4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayeredLod(texture<short, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float texCubemapLayeredLod(texture<unsigned short, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayeredLod(texture<short1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 texCubemapLayeredLod(texture<ushort1, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayeredLod(texture<short2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 texCubemapLayeredLod(texture<ushort2, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayeredLod(texture<short4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 texCubemapLayeredLod(texture<ushort4, 0xFC, cudaReadModeNormalizedFloat> t, float x, float y, float z, int layer, float level);


template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchgrad(texture<T, texType, readMode> t, float4 i, float4 dPdx, float4 dPdy, int d = texType)
{
  switch(d) {
  case 1: return __utexfetchgrad1D(t, i, dPdx, dPdy);
  case 2: return __utexfetchgrad2D(t, i, dPdx, dPdy);

  default: return __utexfetchgrad3D(t, i, dPdx, dPdy);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchgrad(texture<T, texType, readMode> t, float4 i, float4 dPdx, float4 dPdy, int d = texType)
{
  switch(d) {
  case 1: return __itexfetchgrad1D(t, i, dPdx, dPdy);
  case 2: return __itexfetchgrad2D(t, i, dPdx, dPdy);

  default: return __itexfetchgrad3D(t, i, dPdx, dPdy);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchgrad(texture<T, texType, readMode> t, float4 i, float4 dPdx, float4 dPdy, int d = texType)
{
  switch(d) {
  case 1: return __ftexfetchgrad1D(t, i, dPdx, dPdy);
  case 2: return __ftexfetchgrad2D(t, i, dPdx, dPdy);

  default: return __ftexfetchgrad3D(t, i, dPdx, dPdy);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
uint4 __utexfetchgradl(texture<T, texType, readMode> t, float4 i, int l, float4 dPdx, float4 dPdy, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __utexfetchgradl1D(t, i, l, dPdx, dPdy);

  default: return __utexfetchgradl2D(t, i, l, dPdx, dPdy);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
int4 __itexfetchgradl(texture<T, texType, readMode> t, float4 i, int l, float4 dPdx, float4 dPdy, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __itexfetchgradl1D(t, i, l, dPdx, dPdy);

  default: return __itexfetchgradl2D(t, i, l, dPdx, dPdy);
  }
}

template<class T, int texType, enum cudaTextureReadMode readMode>
static __inline__ __attribute__((always_inline)) __attribute__((device))
float4 __ftexfetchgradl(texture<T, texType, readMode> t, float4 i, int l, float4 dPdx, float4 dPdy, int d = (texType & 0xF))
{
  switch(d) {
  case 1: return __ftexfetchgradl1D(t, i, l, dPdx, dPdy);

  default: return __ftexfetchgradl2D(t, i, l, dPdx, dPdy);
  }
}
# 3118 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex1DGrad(texture<char, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex1DGrad(texture<signed char, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex1DGrad(texture<unsigned char, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex1DGrad(texture<char1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex1DGrad(texture<uchar1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex1DGrad(texture<char2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex1DGrad(texture<uchar2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex1DGrad(texture<char4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex1DGrad(texture<uchar4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex1DGrad(texture<short, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex1DGrad(texture<unsigned short, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex1DGrad(texture<short1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex1DGrad(texture<ushort1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short2 tex1DGrad(texture<short2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort2 tex1DGrad(texture<ushort2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short4 tex1DGrad(texture<short4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort4 tex1DGrad(texture<ushort4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);







static __inline__ __attribute__((always_inline)) __attribute__((device)) int tex1DGrad(texture<int, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned int tex1DGrad(texture<unsigned int, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int1 tex1DGrad(texture<int1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint1 tex1DGrad(texture<uint1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int2 tex1DGrad(texture<int2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint2 tex1DGrad(texture<uint2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) int4 tex1DGrad(texture<int4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uint4 tex1DGrad(texture<uint4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);
# 3218 "/usr/local/cuda/include/texture_fetch_functions.h"
static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DGrad(texture<float, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DGrad(texture<float1, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DGrad(texture<float2, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DGrad(texture<float4, 0x01, cudaReadModeElementType> t, float x, float dPdx, float dPdy);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DGrad(texture<char, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DGrad(texture<signed char, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DGrad(texture<unsigned char, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DGrad(texture<char1, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DGrad(texture<uchar1, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DGrad(texture<char2, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DGrad(texture<uchar2, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DGrad(texture<char4, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DGrad(texture<uchar4, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);







static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DGrad(texture<short, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float tex1DGrad(texture<unsigned short, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DGrad(texture<short1, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float1 tex1DGrad(texture<ushort1, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DGrad(texture<short2, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float2 tex1DGrad(texture<ushort2, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DGrad(texture<short4, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) float4 tex1DGrad(texture<ushort4, 0x01, cudaReadModeNormalizedFloat> t, float x, float dPdx, float dPdy);







static __inline__ __attribute__((always_inline)) __attribute__((device)) char tex2DGrad(texture<char, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) signed char tex2DGrad(texture<signed char, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned char tex2DGrad(texture<unsigned char, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char1 tex2DGrad(texture<char1, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar1 tex2DGrad(texture<uchar1, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char2 tex2DGrad(texture<char2, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar2 tex2DGrad(texture<uchar2, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) char4 tex2DGrad(texture<char4, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) uchar4 tex2DGrad(texture<uchar4, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);







static __inline__ __attribute__((always_inline)) __attribute__((device)) short tex2DGrad(texture<short, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) unsigned short tex2DGrad(texture<unsigned short, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) short1 tex2DGrad(texture<short1, 0x02, cudaReadModeElementType> t, float x, float y, float2 dPdx, float2 dPdy);

static __inline__ __attribute__((always_inline)) __attribute__((device)) ushort1 tex2DGrad(t