/*
 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
 *
 * SPDX-License-Identifier: MIT
 */
/* ============================================================================
 * hrr_api_args.h  -  AUTO-GENERATED by gen_hrr_api_args.py
 *
 * DO NOT EDIT MANUALLY.
 * Regenerate with:
 *     python gen_hrr_api_args.py
 *
 * One packed struct per HIP API covering both HipDispatchTable (runtime) and
 * HipCompilerDispatchTable (compiler stubs).
 *
 * Archive format (v3):
 *   events.bin:
 *     [0..7]   hrr_file_header  { magic, version, reserved }
 *     [8..]    hrr_event_header (32 bytes) + payload bytes, repeated per event
 *   blobs/<2hex>/   content-addressed raw buffers (FNV-1a-128 hash)
 *   code_objects/   .hsaco ELFs keyed by hash
 *
 * hrr_event_header fields (32 bytes, pack(1)):
 *   - event_type     uint16_t  hrr_api_id_t index
 *   - sequence_id    uint64_t  monotonically increasing per capture session
 *   - timestamp_ns   uint64_t  wall-clock at capture time
 *   - thread_id      uint64_t  OS thread that made the call (cached per thread)
 *   - payload_length uint16_t  total record size in bytes (incl. header)
 *   - reserved       uint8_t[4]  padding to 32 bytes
 *
 * Payload bytes (after the 32-byte header):
 *   - ret          int32_t (hipError_t); absent for void returns
 *   - pointer / handle types   uint64_t  (address stored as integer)
 *   - dim3 / uint3             expanded to three uint32_t _x/_y/_z fields
 *   - size_t                   uint64_t
 *   - scalars                  native C type (int32_t, uint32_t, float, ...)
 *
 * Extra fields on selected APIs (blob hashes, module_id) are appended AFTER
 * the normal parameters — see EXTRA_FIELDS in gen_hrr_api_args.py.
 *
 * The structs use #pragma pack(1) so layout is identical on all platforms.
 * ============================================================================
 */
#pragma once

#include <stdint.h>

/* ---- Archive format constants ---- */
#define HRR_MAGIC   ((uint32_t)0x52524845u)  /* "HRRE" */
#define HRR_VERSION ((uint16_t)3u)

/* Written once at byte 0 of events.bin. */
#pragma pack(push, 1)
typedef struct {
    uint32_t magic;    /* HRR_MAGIC                */
    uint16_t version;  /* HRR_VERSION              */
    uint16_t reserved; /* zero                     */
} hrr_file_header;
#pragma pack(pop)

#ifdef __cplusplus
static_assert(sizeof(hrr_file_header) == 8, "hrr_file_header must be 8 bytes");
#endif

#pragma pack(push, 1)

/* Per-record prefix embedded as the first member of every hrr_args_* struct.
 * write_event_raw() fills all fields before writing. 32 bytes, pack(1).
 * magic and version are in hrr_file_header at byte 0 of events.bin (once). */
typedef struct {
    uint16_t event_type;     /* hrr_api_id_t index of the captured API    */
    uint64_t sequence_id;    /* monotonically increasing counter          */
    uint64_t timestamp_ns;   /* wall-clock at capture time (MONOTONIC)    */
    uint64_t thread_id;      /* OS thread ID (cached per thread)          */
    uint16_t payload_length; /* total record size in bytes (incl. header) */
    uint8_t  reserved[4];    /* padding to 32 bytes; zero on write        */
} hrr_event_header;

#ifdef __cplusplus
static_assert(sizeof(hrr_event_header) == 32, "hrr_event_header must be 32 bytes");
#endif


/* ---- Compiler dispatch stubs ---- */

/* hipError_t __hipPopCallConfiguration(dim3* gridDim, dim3* blockDim, size_t* sharedMem, hipStream_t* stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t gridDim;
    uint64_t blockDim;
    uint64_t sharedMem;
    uint64_t stream;
} hrr_args___hipPopCallConfiguration;

/* hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint32_t gridDim_x;
    uint32_t gridDim_y;
    uint32_t gridDim_z;
    uint32_t blockDim_x;
    uint32_t blockDim_y;
    uint32_t blockDim_z;
    uint64_t sharedMem;
    uint64_t stream;
} hrr_args___hipPushCallConfiguration;

/* void** __hipRegisterFatBinary(const void* data) */
typedef struct {
    hrr_event_header hdr;
    uint64_t ret;
    uint64_t blob_hash_lo;  /* FNV-1a-128 lo of fat binary */
    uint64_t blob_hash_hi;  /* FNV-1a-128 hi */
    uint64_t blob_size;  /* fat binary byte count */
} hrr_args___hipRegisterFatBinary;

/* void __hipRegisterFunction(void** modules, const void* hostFunction, char* deviceFunction, const char* deviceName, unsigned int threadLimit, uint3* tid, uint3* bid, dim3* blockDim, dim3* gridDim, int* wSize) */
typedef struct {
    hrr_event_header hdr;
    uint64_t modules;
    uint64_t hostFunction;
    uint64_t deviceFunction;
    uint64_t deviceName;
    uint32_t threadLimit;
    uint64_t tid;
    uint64_t bid;
    uint64_t blockDim;
    uint64_t gridDim;
    uint64_t wSize;
} hrr_args___hipRegisterFunction;

/* void __hipRegisterManagedVar(void* hipModule, void** pointer, void* init_value, const char* name, size_t size, unsigned align) */
typedef struct {
    hrr_event_header hdr;
    uint64_t hipModule;
    uint64_t pointer;
    uint64_t init_value;
    uint64_t name;
    uint64_t size;
    uint32_t align;
} hrr_args___hipRegisterManagedVar;

/* void __hipRegisterSurface(void** modules, void* var, char* hostVar, char* deviceVar, int type, int ext) */
typedef struct {
    hrr_event_header hdr;
    uint64_t modules;
    uint64_t var;
    uint64_t hostVar;
    uint64_t deviceVar;
    int32_t type;
    int32_t ext;
} hrr_args___hipRegisterSurface;

/* void __hipRegisterTexture(void** modules, void* var, char* hostVar, char* deviceVar, int type, int norm, int ext) */
typedef struct {
    hrr_event_header hdr;
    uint64_t modules;
    uint64_t var;
    uint64_t hostVar;
    uint64_t deviceVar;
    int32_t type;
    int32_t norm;
    int32_t ext;
} hrr_args___hipRegisterTexture;

/* void __hipRegisterVar(void** modules, void* var, char* hostVar, char* deviceVar, int ext, size_t size, int constant, int global) */
typedef struct {
    hrr_event_header hdr;
    uint64_t modules;
    uint64_t var;
    uint64_t hostVar;
    uint64_t deviceVar;
    int32_t ext;
    uint64_t size;
    int32_t constant;
    int32_t global;
} hrr_args___hipRegisterVar;

/* void __hipUnregisterFatBinary(void** modules) */
typedef struct {
    hrr_event_header hdr;
    uint64_t modules;
} hrr_args___hipUnregisterFatBinary;

/* ---- Runtime dispatch APIs ---- */

/* const char* hipApiName(uint32_t id) */
typedef struct {
    hrr_event_header hdr;
    uint64_t ret;
    uint32_t id;
} hrr_args_hipApiName;

/* hipError_t hipArray3DCreate(hipArray_t* array, const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t array;
    uint64_t pAllocateArray;
    uint8_t array3d_desc_bytes[40];  /* HIP_ARRAY3D_DESCRIPTOR inline copy */
} hrr_args_hipArray3DCreate;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(HIP_ARRAY3D_DESCRIPTOR) <= 40, "hrr_args_hipArray3DCreate::array3d_desc_bytes[40] too small for HIP_ARRAY3D_DESCRIPTOR");
#endif

/* hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR* pArrayDescriptor, hipArray_t array) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pArrayDescriptor;
    uint64_t array;
} hrr_args_hipArray3DGetDescriptor;

/* hipError_t hipArrayCreate(hipArray_t* pHandle, const HIP_ARRAY_DESCRIPTOR* pAllocateArray) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pHandle;
    uint64_t pAllocateArray;
    uint8_t array_desc_bytes[24];  /* HIP_ARRAY_DESCRIPTOR inline copy */
} hrr_args_hipArrayCreate;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(HIP_ARRAY_DESCRIPTOR) <= 24, "hrr_args_hipArrayCreate::array_desc_bytes[24] too small for HIP_ARRAY_DESCRIPTOR");
#endif

/* hipError_t hipArrayDestroy(hipArray_t array) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t array;
} hrr_args_hipArrayDestroy;

/* hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR* pArrayDescriptor, hipArray_t array) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pArrayDescriptor;
    uint64_t array;
} hrr_args_hipArrayGetDescriptor;

/* hipError_t hipArrayGetInfo(hipChannelFormatDesc* desc, hipExtent* extent, unsigned int* flags, hipArray_t array) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t desc;
    uint64_t extent;
    uint64_t flags;
    uint64_t array;
} hrr_args_hipArrayGetInfo;

/* hipError_t hipBindTexture(size_t* offset, const textureReference* tex, const void* devPtr, const hipChannelFormatDesc* desc, size_t size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t offset;
    uint64_t tex;
    uint64_t devPtr;
    uint64_t desc;
    uint64_t size;
} hrr_args_hipBindTexture;

/* hipError_t hipBindTexture2D(size_t* offset, const textureReference* tex, const void* devPtr, const hipChannelFormatDesc* desc, size_t width, size_t height, size_t pitch) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t offset;
    uint64_t tex;
    uint64_t devPtr;
    uint64_t desc;
    uint64_t width;
    uint64_t height;
    uint64_t pitch;
} hrr_args_hipBindTexture2D;

/* hipError_t hipBindTextureToArray(const textureReference* tex, hipArray_const_t array, const hipChannelFormatDesc* desc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t tex;
    uint64_t array;
    uint64_t desc;
} hrr_args_hipBindTextureToArray;

/* hipError_t hipBindTextureToMipmappedArray(const textureReference* tex, hipMipmappedArray_const_t mipmappedArray, const hipChannelFormatDesc* desc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t tex;
    uint64_t mipmappedArray;
    uint64_t desc;
} hrr_args_hipBindTextureToMipmappedArray;

/* hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
    uint64_t prop;
} hrr_args_hipChooseDevice;

/* hipError_t hipChooseDeviceR0000(int* device, const hipDeviceProp_tR0000* properties) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
    uint64_t properties;
} hrr_args_hipChooseDeviceR0000;

/* hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint32_t gridDim_x;
    uint32_t gridDim_y;
    uint32_t gridDim_z;
    uint32_t blockDim_x;
    uint32_t blockDim_y;
    uint32_t blockDim_z;
    uint64_t sharedMem;
    uint64_t stream;
} hrr_args_hipConfigureCall;

/* hipError_t hipCreateSurfaceObject(hipSurfaceObject_t* pSurfObject, const hipResourceDesc* pResDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pSurfObject;
    uint64_t pResDesc;
} hrr_args_hipCreateSurfaceObject;

/* hipError_t hipCreateTextureObject(hipTextureObject_t* pTexObject, const hipResourceDesc* pResDesc, const hipTextureDesc* pTexDesc, const struct hipResourceViewDesc* pResViewDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pTexObject;
    uint64_t pResDesc;
    uint64_t pTexDesc;
    uint64_t pResViewDesc;
} hrr_args_hipCreateTextureObject;

/* hipError_t hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint32_t flags;
    uint64_t device;
} hrr_args_hipCtxCreate;

/* hipError_t hipCtxDestroy(hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipCtxDestroy;

/* hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t peerCtx;
} hrr_args_hipCtxDisablePeerAccess;

/* hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t peerCtx;
    uint32_t flags;
} hrr_args_hipCtxEnablePeerAccess;

/* hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int* apiVersion) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint64_t apiVersion;
} hrr_args_hipCtxGetApiVersion;

/* hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t cacheConfig;
} hrr_args_hipCtxGetCacheConfig;

/* hipError_t hipCtxGetCurrent(hipCtx_t* ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipCtxGetCurrent;

/* hipError_t hipCtxGetDevice(hipDevice_t* device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
} hrr_args_hipCtxGetDevice;

/* hipError_t hipCtxGetFlags(unsigned int* flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t flags;
} hrr_args_hipCtxGetFlags;

/* hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pConfig;
} hrr_args_hipCtxGetSharedMemConfig;

/* hipError_t hipCtxPopCurrent(hipCtx_t* ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipCtxPopCurrent;

/* hipError_t hipCtxPushCurrent(hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipCtxPushCurrent;

/* hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t cacheConfig;
} hrr_args_hipCtxSetCacheConfig;

/* hipError_t hipCtxSetCurrent(hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipCtxSetCurrent;

/* hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t config;
} hrr_args_hipCtxSetSharedMemConfig;

/* hipError_t hipCtxSynchronize() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipCtxSynchronize;

/* hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t extMem;
} hrr_args_hipDestroyExternalMemory;

/* hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t extSem;
} hrr_args_hipDestroyExternalSemaphore;

/* hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t surfaceObject;
} hrr_args_hipDestroySurfaceObject;

/* hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t textureObject;
} hrr_args_hipDestroyTextureObject;

/* hipError_t hipDeviceCanAccessPeer(int* canAccessPeer, int deviceId, int peerDeviceId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t canAccessPeer;
    int32_t deviceId;
    int32_t peerDeviceId;
} hrr_args_hipDeviceCanAccessPeer;

/* hipError_t hipDeviceComputeCapability(int* major, int* minor, hipDevice_t device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t major;
    uint64_t minor;
    uint64_t device;
} hrr_args_hipDeviceComputeCapability;

/* hipError_t hipDeviceDisablePeerAccess(int peerDeviceId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t peerDeviceId;
} hrr_args_hipDeviceDisablePeerAccess;

/* hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t peerDeviceId;
    uint32_t flags;
} hrr_args_hipDeviceEnablePeerAccess;

/* hipError_t hipDeviceGet(hipDevice_t* device, int ordinal) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
    int32_t ordinal;
} hrr_args_hipDeviceGet;

/* hipError_t hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int deviceId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pi;
    int32_t attr;
    int32_t deviceId;
} hrr_args_hipDeviceGetAttribute;

/* hipError_t hipDeviceGetByPCIBusId(int* device, const char* pciBusId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
    uint64_t pciBusId;
} hrr_args_hipDeviceGetByPCIBusId;

/* hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t cacheConfig;
} hrr_args_hipDeviceGetCacheConfig;

/* hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t* mem_pool, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    int32_t device;
} hrr_args_hipDeviceGetDefaultMemPool;

/* hipError_t hipDeviceGetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t device;
    uint64_t /* hipGraphMemAttributeType */ attr;
    uint64_t value;
} hrr_args_hipDeviceGetGraphMemAttribute;

/* hipError_t hipDeviceGetLimit(size_t* pValue, enum hipLimit_t limit) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pValue;
    uint64_t /* enum hipLimit_t */ limit;
} hrr_args_hipDeviceGetLimit;

/* hipError_t hipDeviceGetMemPool(hipMemPool_t* mem_pool, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    int32_t device;
} hrr_args_hipDeviceGetMemPool;

/* hipError_t hipDeviceGetName(char* name, int len, hipDevice_t device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t name;
    int32_t len;
    uint64_t device;
} hrr_args_hipDeviceGetName;

/* hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr, int srcDevice, int dstDevice) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t value;
    int32_t attr;
    int32_t srcDevice;
    int32_t dstDevice;
} hrr_args_hipDeviceGetP2PAttribute;

/* hipError_t hipDeviceGetPCIBusId(char* pciBusId, int len, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pciBusId;
    int32_t len;
    int32_t device;
} hrr_args_hipDeviceGetPCIBusId;

/* hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pConfig;
} hrr_args_hipDeviceGetSharedMemConfig;

/* hipError_t hipDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t leastPriority;
    uint64_t greatestPriority;
} hrr_args_hipDeviceGetStreamPriorityRange;

/* hipError_t hipDeviceGetUuid(hipUUID* uuid, hipDevice_t device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t uuid;
    uint64_t device;
} hrr_args_hipDeviceGetUuid;

/* hipError_t hipDeviceGraphMemTrim(int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t device;
} hrr_args_hipDeviceGraphMemTrim;

/* hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int* flags, int* active) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev;
    uint64_t flags;
    uint64_t active;
} hrr_args_hipDevicePrimaryCtxGetState;

/* hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev;
} hrr_args_hipDevicePrimaryCtxRelease;

/* hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev;
} hrr_args_hipDevicePrimaryCtxReset;

/* hipError_t hipDevicePrimaryCtxRetain(hipCtx_t* pctx, hipDevice_t dev) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pctx;
    uint64_t dev;
} hrr_args_hipDevicePrimaryCtxRetain;

/* hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev;
    uint32_t flags;
} hrr_args_hipDevicePrimaryCtxSetFlags;

/* hipError_t hipDeviceReset() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipDeviceReset;

/* hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t cacheConfig;
} hrr_args_hipDeviceSetCacheConfig;

/* hipError_t hipDeviceSetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t device;
    uint64_t /* hipGraphMemAttributeType */ attr;
    uint64_t value;
} hrr_args_hipDeviceSetGraphMemAttribute;

/* hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* enum hipLimit_t */ limit;
    uint64_t value;
} hrr_args_hipDeviceSetLimit;

/* hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t device;
    uint64_t mem_pool;
} hrr_args_hipDeviceSetMemPool;

/* hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t config;
} hrr_args_hipDeviceSetSharedMemConfig;

/* hipError_t hipDeviceSynchronize() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipDeviceSynchronize;

/* hipError_t hipDeviceTotalMem(size_t* bytes, hipDevice_t device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t bytes;
    uint64_t device;
} hrr_args_hipDeviceTotalMem;

/* hipError_t hipDriverGetVersion(int* driverVersion) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t driverVersion;
} hrr_args_hipDriverGetVersion;

/* hipError_t hipDrvGetErrorName(hipError_t hipError, const char** errorString) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t hipError;
    uint64_t errorString;
} hrr_args_hipDrvGetErrorName;

/* hipError_t hipDrvGetErrorString(hipError_t hipError, const char** errorString) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t hipError;
    uint64_t errorString;
} hrr_args_hipDrvGetErrorString;

/* hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph, const hipGraphNode_t* dependencies, size_t numDependencies, const HIP_MEMCPY3D* copyParams, hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t phGraphNode;
    uint64_t hGraph;
    uint64_t dependencies;
    uint64_t numDependencies;
    uint64_t copyParams;
    uint64_t ctx;
} hrr_args_hipDrvGraphAddMemcpyNode;

/* hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pCopy;
} hrr_args_hipDrvMemcpy2DUnaligned;

/* hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pCopy;
} hrr_args_hipDrvMemcpy3D;

/* hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D* pCopy, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pCopy;
    uint64_t stream;
} hrr_args_hipDrvMemcpy3DAsync;

/* hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute* attributes, void** data, hipDeviceptr_t ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint32_t numAttributes;
    uint64_t attributes;
    uint64_t data;
    uint64_t ptr;
} hrr_args_hipDrvPointerGetAttributes;

/* hipError_t hipEventCreate(hipEvent_t* event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
} hrr_args_hipEventCreate;

/* hipError_t hipEventCreateWithFlags(hipEvent_t* event, unsigned flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
    uint32_t flags;
} hrr_args_hipEventCreateWithFlags;

/* hipError_t hipEventDestroy(hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
} hrr_args_hipEventDestroy;

/* hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ms;
    uint64_t start;
    uint64_t stop;
} hrr_args_hipEventElapsedTime;

/* hipError_t hipEventQuery(hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
} hrr_args_hipEventQuery;

/* hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
    uint64_t stream;
} hrr_args_hipEventRecord;

/* hipError_t hipEventSynchronize(hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
} hrr_args_hipEventSynchronize;

/* hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t* linktype, uint32_t* hopcount) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t device1;
    int32_t device2;
    uint64_t linktype;
    uint64_t hopcount;
} hrr_args_hipExtGetLinkTypeAndHopCount;

/* hipError_t hipExtLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks, void** args, size_t sharedMemBytes, hipStream_t stream, hipEvent_t startEvent, hipEvent_t stopEvent, int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t function_address;
    uint32_t numBlocks_x;
    uint32_t numBlocks_y;
    uint32_t numBlocks_z;
    uint32_t dimBlocks_x;
    uint32_t dimBlocks_y;
    uint32_t dimBlocks_z;
    uint64_t args;
    uint64_t sharedMemBytes;
    uint64_t stream;
    uint64_t startEvent;
    uint64_t stopEvent;
    int32_t flags;
} hrr_args_hipExtLaunchKernel;

/* hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t launchParamsList;
    int32_t numDevices;
    uint32_t flags;
} hrr_args_hipExtLaunchMultiKernelMultiDevice;

/* hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t sizeBytes;
    uint32_t flags;
} hrr_args_hipExtMallocWithFlags;

/* hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize, const uint32_t* cuMask) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint32_t cuMaskSize;
    uint64_t cuMask;
} hrr_args_hipExtStreamCreateWithCUMask;

/* hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t* cuMask) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint32_t cuMaskSize;
    uint64_t cuMask;
} hrr_args_hipExtStreamGetCUMask;

/* hipError_t hipExternalMemoryGetMappedBuffer(void** devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc* bufferDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
    uint64_t extMem;
    uint64_t bufferDesc;
} hrr_args_hipExternalMemoryGetMappedBuffer;

/* hipError_t hipFree(void* ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
} hrr_args_hipFree;

/* hipError_t hipFreeArray(hipArray_t array) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t array;
} hrr_args_hipFreeArray;

/* hipError_t hipFreeAsync(void* dev_ptr, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t stream;
} hrr_args_hipFreeAsync;

/* hipError_t hipFreeHost(void* ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
} hrr_args_hipFreeHost;

/* hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mipmappedArray;
} hrr_args_hipFreeMipmappedArray;

/* hipError_t hipFuncGetAttribute(int* value, hipFunction_attribute attrib, hipFunction_t hfunc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t value;
    uint64_t /* hipFunction_attribute */ attrib;
    uint64_t hfunc;
} hrr_args_hipFuncGetAttribute;

/* hipError_t hipFuncGetAttributes(struct hipFuncAttributes* attr, const void* func) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t attr;
    uint64_t func;
} hrr_args_hipFuncGetAttributes;

/* hipError_t hipFuncSetAttribute(const void* func, hipFuncAttribute attr, int value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t func;
    int32_t attr;
    int32_t value;
} hrr_args_hipFuncSetAttribute;

/* hipError_t hipFuncSetCacheConfig(const void* func, hipFuncCache_t config) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t func;
    int32_t config;
} hrr_args_hipFuncSetCacheConfig;

/* hipError_t hipFuncSetSharedMemConfig(const void* func, hipSharedMemConfig config) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t func;
    int32_t config;
} hrr_args_hipFuncSetSharedMemConfig;

/* hipError_t hipGLGetDevices(unsigned int* pHipDeviceCount, int* pHipDevices, unsigned int hipDeviceCount, hipGLDeviceList deviceList) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pHipDeviceCount;
    uint64_t pHipDevices;
    uint32_t hipDeviceCount;
    uint64_t /* hipGLDeviceList */ deviceList;
} hrr_args_hipGLGetDevices;

/* hipError_t hipGetChannelDesc(hipChannelFormatDesc* desc, hipArray_const_t array) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t desc;
    uint64_t array;
} hrr_args_hipGetChannelDesc;

/* hipError_t hipGetDevice(int* deviceId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t deviceId;
} hrr_args_hipGetDevice;

/* hipError_t hipGetDeviceCount(int* count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t count;
} hrr_args_hipGetDeviceCount;

/* hipError_t hipGetDeviceFlags(unsigned int* flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t flags;
} hrr_args_hipGetDeviceFlags;

/* hipError_t hipGetDevicePropertiesR0600(hipDeviceProp_tR0600* prop, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t prop;
    int32_t device;
} hrr_args_hipGetDevicePropertiesR0600;

/* hipError_t hipGetDevicePropertiesR0000(hipDeviceProp_tR0000* prop, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t prop;
    int32_t device;
} hrr_args_hipGetDevicePropertiesR0000;

/* const char* hipGetErrorName(hipError_t hip_error) */
typedef struct {
    hrr_event_header hdr;
    uint64_t ret;
    int32_t hip_error;
} hrr_args_hipGetErrorName;

/* const char* hipGetErrorString(hipError_t hipError) */
typedef struct {
    hrr_event_header hdr;
    uint64_t ret;
    int32_t hipError;
} hrr_args_hipGetErrorString;

/* hipError_t hipGetLastError() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipGetLastError;

/* hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t levelArray;
    uint64_t mipmappedArray;
    uint32_t level;
} hrr_args_hipGetMipmappedArrayLevel;

/* hipError_t hipGetSymbolAddress(void** devPtr, const void* symbol) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
    uint64_t symbol;
} hrr_args_hipGetSymbolAddress;

/* hipError_t hipGetSymbolSize(size_t* size, const void* symbol) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t size;
    uint64_t symbol;
} hrr_args_hipGetSymbolSize;

/* hipError_t hipGetTextureAlignmentOffset(size_t* offset, const textureReference* texref) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t offset;
    uint64_t texref;
} hrr_args_hipGetTextureAlignmentOffset;

/* hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc, hipTextureObject_t textureObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pResDesc;
    uint64_t textureObject;
} hrr_args_hipGetTextureObjectResourceDesc;

/* hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc, hipTextureObject_t textureObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pResViewDesc;
    uint64_t textureObject;
} hrr_args_hipGetTextureObjectResourceViewDesc;

/* hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc, hipTextureObject_t textureObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pTexDesc;
    uint64_t textureObject;
} hrr_args_hipGetTextureObjectTextureDesc;

/* hipError_t hipGetTextureReference(const textureReference** texref, const void* symbol) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texref;
    uint64_t symbol;
} hrr_args_hipGetTextureReference;

/* hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, hipGraph_t childGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t childGraph;
} hrr_args_hipGraphAddChildGraphNode;

/* hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t* from, const hipGraphNode_t* to, size_t numDependencies) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t from;
    uint64_t to;
    uint64_t numDependencies;
} hrr_args_hipGraphAddDependencies;

/* hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
} hrr_args_hipGraphAddEmptyNode;

/* hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t event;
} hrr_args_hipGraphAddEventRecordNode;

/* hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t event;
} hrr_args_hipGraphAddEventWaitNode;

/* hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const hipHostNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t pNodeParams;
} hrr_args_hipGraphAddHostNode;

/* hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const hipKernelNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t pNodeParams;
} hrr_args_hipGraphAddKernelNode;

/* hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, hipMemAllocNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t pNodeParams;
} hrr_args_hipGraphAddMemAllocNode;

/* hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, void* dev_ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t dev_ptr;
} hrr_args_hipGraphAddMemFreeNode;

/* hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const hipMemcpy3DParms* pCopyParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t pCopyParams;
} hrr_args_hipGraphAddMemcpyNode;

/* hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t dst;
    uint64_t src;
    uint64_t count;
    int32_t kind;
} hrr_args_hipGraphAddMemcpyNode1D;

/* hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* symbol, size_t count, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t dst;
    uint64_t symbol;
    uint64_t count;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipGraphAddMemcpyNodeFromSymbol;

/* hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const void* symbol, const void* src, size_t count, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t symbol;
    uint64_t src;
    uint64_t count;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipGraphAddMemcpyNodeToSymbol;

/* hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const hipMemsetParams* pMemsetParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t pMemsetParams;
} hrr_args_hipGraphAddMemsetNode;

/* hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t* pGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pGraph;
} hrr_args_hipGraphChildGraphNodeGetGraph;

/* hipError_t hipGraphClone(hipGraph_t* pGraphClone, hipGraph_t originalGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphClone;
    uint64_t originalGraph;
} hrr_args_hipGraphClone;

/* hipError_t hipGraphCreate(hipGraph_t* pGraph, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraph;
    uint32_t flags;
} hrr_args_hipGraphCreate;

/* hipError_t hipGraphDebugDotPrint(hipGraph_t graph, const char* path, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t path;
    uint32_t flags;
} hrr_args_hipGraphDebugDotPrint;

/* hipError_t hipGraphDestroy(hipGraph_t graph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
} hrr_args_hipGraphDestroy;

/* hipError_t hipGraphDestroyNode(hipGraphNode_t node) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
} hrr_args_hipGraphDestroyNode;

/* hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t* event_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t event_out;
} hrr_args_hipGraphEventRecordNodeGetEvent;

/* hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t event;
} hrr_args_hipGraphEventRecordNodeSetEvent;

/* hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t* event_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t event_out;
} hrr_args_hipGraphEventWaitNodeGetEvent;

/* hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t event;
} hrr_args_hipGraphEventWaitNodeSetEvent;

/* hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipGraph_t childGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t childGraph;
} hrr_args_hipGraphExecChildGraphNodeSetParams;

/* hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graphExec;
} hrr_args_hipGraphExecDestroy;

/* hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t event;
} hrr_args_hipGraphExecEventRecordNodeSetEvent;

/* hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t event;
} hrr_args_hipGraphExecEventWaitNodeSetEvent;

/* hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipHostNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphExecHostNodeSetParams;

/* hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipKernelNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphExecKernelNodeSetParams;

/* hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipMemcpy3DParms* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphExecMemcpyNodeSetParams;

/* hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node, void* dst, const void* src, size_t count, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t dst;
    uint64_t src;
    uint64_t count;
    int32_t kind;
} hrr_args_hipGraphExecMemcpyNodeSetParams1D;

/* hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node, void* dst, const void* symbol, size_t count, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t dst;
    uint64_t symbol;
    uint64_t count;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipGraphExecMemcpyNodeSetParamsFromSymbol;

/* hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node, const void* symbol, const void* src, size_t count, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t symbol;
    uint64_t src;
    uint64_t count;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipGraphExecMemcpyNodeSetParamsToSymbol;

/* hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipMemsetParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphExecMemsetNodeSetParams;

/* hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph, hipGraphNode_t* hErrorNode_out, hipGraphExecUpdateResult* updateResult_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hGraph;
    uint64_t hErrorNode_out;
    uint64_t updateResult_out;
} hrr_args_hipGraphExecUpdate;

/* hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t* from, hipGraphNode_t* to, size_t* numEdges) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t from;
    uint64_t to;
    uint64_t numEdges;
} hrr_args_hipGraphGetEdges;

/* hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t* nodes, size_t* numNodes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t nodes;
    uint64_t numNodes;
} hrr_args_hipGraphGetNodes;

/* hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes, size_t* pNumRootNodes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t pRootNodes;
    uint64_t pNumRootNodes;
} hrr_args_hipGraphGetRootNodes;

/* hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphHostNodeGetParams;

/* hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphHostNodeSetParams;

/* hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph, hipGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphExec;
    uint64_t graph;
    uint64_t pErrorNode;
    uint64_t pLogBuffer;
    uint64_t bufferSize;
} hrr_args_hipGraphInstantiate;

/* hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph, unsigned long long flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphExec;
    uint64_t graph;
    uint64_t flags;
} hrr_args_hipGraphInstantiateWithFlags;

/* hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hSrc;
    uint64_t hDst;
} hrr_args_hipGraphKernelNodeCopyAttributes;

/* hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, hipKernelNodeAttrValue* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    int32_t attr;
    uint64_t value;
} hrr_args_hipGraphKernelNodeGetAttribute;

/* hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphKernelNodeGetParams;

/* hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, const hipKernelNodeAttrValue* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    int32_t attr;
    uint64_t value;
} hrr_args_hipGraphKernelNodeSetAttribute;

/* hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphKernelNodeSetParams;

/* hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graphExec;
    uint64_t stream;
} hrr_args_hipGraphLaunch;

/* hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphMemAllocNodeGetParams;

/* hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void* dev_ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t dev_ptr;
} hrr_args_hipGraphMemFreeNodeGetParams;

/* hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphMemcpyNodeGetParams;

/* hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphMemcpyNodeSetParams;

/* hipError_t hipGraphMemcpyNodeSetParams1D(hipGraphNode_t node, void* dst, const void* src, size_t count, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t dst;
    uint64_t src;
    uint64_t count;
    int32_t kind;
} hrr_args_hipGraphMemcpyNodeSetParams1D;

/* hipError_t hipGraphMemcpyNodeSetParamsFromSymbol(hipGraphNode_t node, void* dst, const void* symbol, size_t count, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t dst;
    uint64_t symbol;
    uint64_t count;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipGraphMemcpyNodeSetParamsFromSymbol;

/* hipError_t hipGraphMemcpyNodeSetParamsToSymbol(hipGraphNode_t node, const void* symbol, const void* src, size_t count, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t symbol;
    uint64_t src;
    uint64_t count;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipGraphMemcpyNodeSetParamsToSymbol;

/* hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphMemsetNodeGetParams;

/* hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams* pNodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pNodeParams;
} hrr_args_hipGraphMemsetNodeSetParams;

/* hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode, hipGraph_t clonedGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pNode;
    uint64_t originalNode;
    uint64_t clonedGraph;
} hrr_args_hipGraphNodeFindInClone;

/* hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies, size_t* pNumDependencies) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pDependencies;
    uint64_t pNumDependencies;
} hrr_args_hipGraphNodeGetDependencies;

/* hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pDependentNodes;
    uint64_t pNumDependentNodes;
} hrr_args_hipGraphNodeGetDependentNodes;

/* hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int* isEnabled) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t isEnabled;
} hrr_args_hipGraphNodeGetEnabled;

/* hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType* pType) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t pType;
} hrr_args_hipGraphNodeGetType;

/* hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int isEnabled) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint32_t isEnabled;
} hrr_args_hipGraphNodeSetEnabled;

/* hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t object;
    uint32_t count;
} hrr_args_hipGraphReleaseUserObject;

/* hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t* from, const hipGraphNode_t* to, size_t numDependencies) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t from;
    uint64_t to;
    uint64_t numDependencies;
} hrr_args_hipGraphRemoveDependencies;

/* hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graph;
    uint64_t object;
    uint32_t count;
    uint32_t flags;
} hrr_args_hipGraphRetainUserObject;

/* hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graphExec;
    uint64_t stream;
} hrr_args_hipGraphUpload;

/* hipError_t hipGraphicsGLRegisterBuffer(hipGraphicsResource** resource, GLuint buffer, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t resource;
    uint64_t /* GLuint */ buffer;
    uint32_t flags;
} hrr_args_hipGraphicsGLRegisterBuffer;

/* hipError_t hipGraphicsGLRegisterImage(hipGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t resource;
    uint64_t /* GLuint */ image;
    uint64_t /* GLenum */ target;
    uint32_t flags;
} hrr_args_hipGraphicsGLRegisterImage;

/* hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t count;
    uint64_t resources;
    uint64_t stream;
} hrr_args_hipGraphicsMapResources;

/* hipError_t hipGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, hipGraphicsResource_t resource) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
    uint64_t size;
    uint64_t /* hipGraphicsResource_t */ resource;
} hrr_args_hipGraphicsResourceGetMappedPointer;

/* hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t array;
    uint64_t /* hipGraphicsResource_t */ resource;
    uint32_t arrayIndex;
    uint32_t mipLevel;
} hrr_args_hipGraphicsSubResourceGetMappedArray;

/* hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t count;
    uint64_t resources;
    uint64_t stream;
} hrr_args_hipGraphicsUnmapResources;

/* hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipGraphicsResource_t */ resource;
} hrr_args_hipGraphicsUnregisterResource;

/* hipError_t hipHostAlloc(void** ptr, size_t size, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
    uint32_t flags;
} hrr_args_hipHostAlloc;

/* hipError_t hipHostFree(void* ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
} hrr_args_hipHostFree;

/* hipError_t hipHostGetDevicePointer(void** devPtr, void* hstPtr, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
    uint64_t hstPtr;
    uint32_t flags;
} hrr_args_hipHostGetDevicePointer;

/* hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t flagsPtr;
    uint64_t hostPtr;
} hrr_args_hipHostGetFlags;

/* hipError_t hipHostMalloc(void** ptr, size_t size, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
    uint32_t flags;
} hrr_args_hipHostMalloc;

/* hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hostPtr;
    uint64_t sizeBytes;
    uint32_t flags;
    uint64_t blob_hash_lo;  /* sysmem blob hash lo */
    uint64_t blob_hash_hi;  /* sysmem blob hash hi */
} hrr_args_hipHostRegister;

/* hipError_t hipHostUnregister(void* hostPtr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hostPtr;
} hrr_args_hipHostUnregister;

/* hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out, const hipExternalMemoryHandleDesc* memHandleDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t extMem_out;
    uint64_t memHandleDesc;
} hrr_args_hipImportExternalMemory;

/* hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out, const hipExternalSemaphoreHandleDesc* semHandleDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t extSem_out;
    uint64_t semHandleDesc;
} hrr_args_hipImportExternalSemaphore;

/* hipError_t hipInit(unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint32_t flags;
} hrr_args_hipInit;

/* hipError_t hipIpcCloseMemHandle(void* devPtr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
} hrr_args_hipIpcCloseMemHandle;

/* hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t* handle, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
    uint64_t event;
} hrr_args_hipIpcGetEventHandle;

/* hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
    uint64_t devPtr;
} hrr_args_hipIpcGetMemHandle;

/* hipError_t hipIpcOpenEventHandle(hipEvent_t* event, hipIpcEventHandle_t handle) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
    uint64_t /* hipIpcEventHandle_t */ handle;
} hrr_args_hipIpcOpenEventHandle;

/* hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
    uint64_t /* hipIpcMemHandle_t */ handle;
    uint32_t flags;
} hrr_args_hipIpcOpenMemHandle;

/* const char* hipKernelNameRef(const hipFunction_t f) */
typedef struct {
    hrr_event_header hdr;
    uint64_t ret;
    uint64_t f;
} hrr_args_hipKernelNameRef;

/* const char* hipKernelNameRefByPtr(const void* hostFunction, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    uint64_t ret;
    uint64_t hostFunction;
    uint64_t stream;
} hrr_args_hipKernelNameRefByPtr;

/* hipError_t hipLaunchByPtr(const void* func) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t func;
} hrr_args_hipLaunchByPtr;

/* hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim, dim3 blockDimX, void** kernelParams, unsigned int sharedMemBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t f;
    uint32_t gridDim_x;
    uint32_t gridDim_y;
    uint32_t gridDim_z;
    uint32_t blockDimX_x;
    uint32_t blockDimX_y;
    uint32_t blockDimX_z;
    uint64_t kernelParams;
    uint32_t sharedMemBytes;
    uint64_t stream;
} hrr_args_hipLaunchCooperativeKernel;

/* hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t launchParamsList;
    int32_t numDevices;
    uint32_t flags;
} hrr_args_hipLaunchCooperativeKernelMultiDevice;

/* hipError_t hipLaunchHostFunc(hipStream_t stream, hipHostFn_t fn, void* userData) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t /* hipHostFn_t */ fn;
    uint64_t userData;
} hrr_args_hipLaunchHostFunc;

/* hipError_t hipLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks, void** args, size_t sharedMemBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t function_address;
    uint32_t numBlocks_x;
    uint32_t numBlocks_y;
    uint32_t numBlocks_z;
    uint32_t dimBlocks_x;
    uint32_t dimBlocks_y;
    uint32_t dimBlocks_z;
    uint64_t args;
    uint64_t sharedMemBytes;
    uint64_t stream;
} hrr_args_hipLaunchKernel;

/* hipError_t hipMalloc(void** ptr, size_t size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
} hrr_args_hipMalloc;

/* hipError_t hipMalloc3D(hipPitchedPtr* pitchedDevPtr, hipExtent extent) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pitchedDevPtr;
    uint64_t /* hipExtent */ extent;
} hrr_args_hipMalloc3D;

/* hipError_t hipMalloc3DArray(hipArray_t* array, const struct hipChannelFormatDesc* desc, struct hipExtent extent, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t array;
    uint64_t desc;
    uint64_t /* struct hipExtent */ extent;
    uint32_t flags;
} hrr_args_hipMalloc3DArray;

/* hipError_t hipMallocArray(hipArray_t* array, const hipChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t array;
    uint64_t desc;
    uint64_t width;
    uint64_t height;
    uint32_t flags;
} hrr_args_hipMallocArray;

/* hipError_t hipMallocAsync(void** dev_ptr, size_t size, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t size;
    uint64_t stream;
} hrr_args_hipMallocAsync;

/* hipError_t hipMallocFromPoolAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t size;
    uint64_t mem_pool;
    uint64_t stream;
} hrr_args_hipMallocFromPoolAsync;

/* hipError_t hipMallocHost(void** ptr, size_t size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
} hrr_args_hipMallocHost;

/* hipError_t hipMallocManaged(void** dev_ptr, size_t size, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t size;
    uint32_t flags;
} hrr_args_hipMallocManaged;

/* hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray, const struct hipChannelFormatDesc* desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mipmappedArray;
    uint64_t desc;
    uint64_t /* struct hipExtent */ extent;
    uint32_t numLevels;
    uint32_t flags;
} hrr_args_hipMallocMipmappedArray;

/* hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t pitch;
    uint64_t width;
    uint64_t height;
} hrr_args_hipMallocPitch;

/* hipError_t hipMemAddressFree(void* devPtr, size_t size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t devPtr;
    uint64_t size;
} hrr_args_hipMemAddressFree;

/* hipError_t hipMemAddressReserve(void** ptr, size_t size, size_t alignment, void* addr, unsigned long long flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
    uint64_t alignment;
    uint64_t addr;
    uint64_t flags;
} hrr_args_hipMemAddressReserve;

/* hipError_t hipMemAdvise(const void* dev_ptr, size_t count, hipMemoryAdvise advice, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t count;
    int32_t advice;
    int32_t device;
} hrr_args_hipMemAdvise;

/* hipError_t hipMemAdvise_v2(const void* dev_ptr, size_t count, hipMemoryAdvise advice, hipMemLocation device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t count;
    int32_t advice;
    uint64_t /* hipMemLocation */ device;
} hrr_args_hipMemAdvise_v2;

/* hipError_t hipMemAllocHost(void** ptr, size_t size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
} hrr_args_hipMemAllocHost;

/* hipError_t hipMemAllocPitch(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptr;
    uint64_t pitch;
    uint64_t widthInBytes;
    uint64_t height;
    uint32_t elementSizeBytes;
} hrr_args_hipMemAllocPitch;

/* hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size, const hipMemAllocationProp* prop, unsigned long long flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
    uint64_t size;
    uint64_t prop;
    uint64_t flags;
} hrr_args_hipMemCreate;

/* hipError_t hipMemExportToShareableHandle(void* shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t shareableHandle;
    uint64_t handle;
    uint64_t /* hipMemAllocationHandleType */ handleType;
    uint64_t flags;
} hrr_args_hipMemExportToShareableHandle;

/* hipError_t hipMemGetAccess(unsigned long long* flags, const hipMemLocation* location, void* ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t flags;
    uint64_t location;
    uint64_t ptr;
} hrr_args_hipMemGetAccess;

/* hipError_t hipMemGetAddressRange(hipDeviceptr_t* pbase, size_t* psize, hipDeviceptr_t dptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pbase;
    uint64_t psize;
    uint64_t dptr;
} hrr_args_hipMemGetAddressRange;

/* hipError_t hipMemGetAllocationGranularity(size_t* granularity, const hipMemAllocationProp* prop, hipMemAllocationGranularity_flags option) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t granularity;
    uint64_t prop;
    uint64_t /* hipMemAllocationGranularity_flags */ option;
    uint8_t alloc_prop_bytes[32];  /* hipMemAllocationProp inline copy */
} hrr_args_hipMemGetAllocationGranularity;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemAllocationProp) <= 32, "hrr_args_hipMemGetAllocationGranularity::alloc_prop_bytes[32] too small for hipMemAllocationProp");
#endif

/* hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop, hipMemGenericAllocationHandle_t handle) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t prop;
    uint64_t handle;
} hrr_args_hipMemGetAllocationPropertiesFromHandle;

/* hipError_t hipMemGetInfo(size_t* free, size_t* total) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t free;
    uint64_t total;
} hrr_args_hipMemGetInfo;

/* hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t* handle, void* osHandle, hipMemAllocationHandleType shHandleType) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
    uint64_t osHandle;
    uint64_t /* hipMemAllocationHandleType */ shHandleType;
} hrr_args_hipMemImportFromShareableHandle;

/* hipError_t hipMemMap(void* ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
    uint64_t offset;
    uint64_t handle;
    uint64_t flags;
} hrr_args_hipMemMap;

/* hipError_t hipMemMapArrayAsync(hipArrayMapInfo* mapInfoList, unsigned int count, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mapInfoList;
    uint32_t count;
    uint64_t stream;
} hrr_args_hipMemMapArrayAsync;

/* hipError_t hipMemPoolCreate(hipMemPool_t* mem_pool, const hipMemPoolProps* pool_props) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    uint64_t pool_props;
    uint8_t pool_props_bytes[88];  /* hipMemPoolProps inline copy */
} hrr_args_hipMemPoolCreate;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemPoolProps) <= 88, "hrr_args_hipMemPoolCreate::pool_props_bytes[88] too small for hipMemPoolProps");
#endif

/* hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
} hrr_args_hipMemPoolDestroy;

/* hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData* export_data, void* dev_ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t export_data;
    uint64_t dev_ptr;
} hrr_args_hipMemPoolExportPointer;

/* hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool, hipMemAllocationHandleType handle_type, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t shared_handle;
    uint64_t mem_pool;
    uint64_t /* hipMemAllocationHandleType */ handle_type;
    uint32_t flags;
} hrr_args_hipMemPoolExportToShareableHandle;

/* hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool, hipMemLocation* location) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t flags;
    uint64_t mem_pool;
    uint64_t location;
} hrr_args_hipMemPoolGetAccess;

/* hipError_t hipMemPoolGetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    int32_t attr;
    uint64_t value;
    uint64_t value_u64;  /* attribute value stored inline (unused at capture) */
} hrr_args_hipMemPoolGetAttribute;

/* hipError_t hipMemPoolImportFromShareableHandle(hipMemPool_t* mem_pool, void* shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    uint64_t shared_handle;
    uint64_t /* hipMemAllocationHandleType */ handle_type;
    uint32_t flags;
} hrr_args_hipMemPoolImportFromShareableHandle;

/* hipError_t hipMemPoolImportPointer(void** dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData* export_data) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t mem_pool;
    uint64_t export_data;
} hrr_args_hipMemPoolImportPointer;

/* hipError_t hipMemPoolSetAccess(hipMemPool_t mem_pool, const hipMemAccessDesc* desc_list, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    uint64_t desc_list;
    uint64_t count;
    uint8_t access_desc_bytes[12];  /* hipMemAccessDesc[0] inline copy */
} hrr_args_hipMemPoolSetAccess;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemAccessDesc) <= 12, "hrr_args_hipMemPoolSetAccess::access_desc_bytes[12] too small for hipMemAccessDesc");
#endif

/* hipError_t hipMemPoolSetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    int32_t attr;
    uint64_t value;
    uint64_t value_u64;  /* attribute value stored inline */
} hrr_args_hipMemPoolSetAttribute;

/* hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mem_pool;
    uint64_t min_bytes_to_hold;
} hrr_args_hipMemPoolTrimTo;

/* hipError_t hipMemPrefetchAsync(const void* dev_ptr, size_t count, int device, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t count;
    int32_t device;
    uint64_t stream;
} hrr_args_hipMemPrefetchAsync;

/* hipError_t hipMemPrefetchAsync_v2(const void* dev_ptr, size_t count, hipMemLocation location, unsigned int flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t count;
    uint64_t /* hipMemLocation */ location;
    uint32_t flags;
    uint64_t stream;
} hrr_args_hipMemPrefetchAsync_v2;

/* hipError_t hipMemPrefetchBatchAsync(void** dev_ptrs, size_t* sizes, size_t count, hipMemLocation* prefetch_locs, size_t* prefetch_loc_idxs, size_t num_prefetch_locs, unsigned long long flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptrs;
    uint64_t sizes;
    uint64_t count;
    uint64_t prefetch_locs;
    uint64_t prefetch_loc_idxs;
    uint64_t num_prefetch_locs;
    uint64_t flags;
    uint64_t stream;
} hrr_args_hipMemPrefetchBatchAsync;

/* hipError_t hipMemDiscardBatchAsync(void** dev_ptrs, size_t* sizes, size_t count, unsigned long long flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptrs;
    uint64_t sizes;
    uint64_t count;
    uint64_t flags;
    uint64_t stream;
} hrr_args_hipMemDiscardBatchAsync;

/* hipError_t hipDrvMemDiscardBatchAsync(hipDeviceptr_t* dptrs, size_t* sizes, size_t count, unsigned long long flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptrs;
    uint64_t sizes;
    uint64_t count;
    uint64_t flags;
    uint64_t stream;
} hrr_args_hipDrvMemDiscardBatchAsync;

/* hipError_t hipMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count, hipMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptrs;
    uint64_t sizes;
    uint64_t count;
    uint64_t prefetchLocs;
    uint64_t prefetchLocIdxs;
    uint64_t numPrefetchLocs;
    uint64_t flags;
    uint64_t stream;
} hrr_args_hipMemDiscardAndPrefetchBatchAsync;

/* hipError_t hipDrvMemDiscardAndPrefetchBatchAsync(hipDeviceptr_t* dptrs, size_t* sizes, size_t count, hipMemLocation* prefetchLocs, size_t* prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptrs;
    uint64_t sizes;
    uint64_t count;
    uint64_t prefetchLocs;
    uint64_t prefetchLocIdxs;
    uint64_t numPrefetchLocs;
    uint64_t flags;
    uint64_t stream;
} hrr_args_hipDrvMemDiscardAndPrefetchBatchAsync;

/* hipError_t hipMemPtrGetInfo(void* ptr, size_t* size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
} hrr_args_hipMemPtrGetInfo;

/* hipError_t hipMemRangeGetAttribute(void* data, size_t data_size, hipMemRangeAttribute attribute, const void* dev_ptr, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t data;
    uint64_t data_size;
    int32_t attribute;
    uint64_t dev_ptr;
    uint64_t count;
} hrr_args_hipMemRangeGetAttribute;

/* hipError_t hipMemRangeGetAttributes(void** data, size_t* data_sizes, hipMemRangeAttribute* attributes, size_t num_attributes, const void* dev_ptr, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t data;
    uint64_t data_sizes;
    uint64_t attributes;
    uint64_t num_attributes;
    uint64_t dev_ptr;
    uint64_t count;
} hrr_args_hipMemRangeGetAttributes;

/* hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
} hrr_args_hipMemRelease;

/* hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t* handle, void* addr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
    uint64_t addr;
} hrr_args_hipMemRetainAllocationHandle;

/* hipError_t hipMemSetAccess(void* ptr, size_t size, const hipMemAccessDesc* desc, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
    uint64_t desc;
    uint64_t count;
    uint8_t access_desc_bytes[12];  /* hipMemAccessDesc[0] inline copy */
} hrr_args_hipMemSetAccess;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemAccessDesc) <= 12, "hrr_args_hipMemSetAccess::access_desc_bytes[12] too small for hipMemAccessDesc");
#endif

/* hipError_t hipMemUnmap(void* ptr, size_t size) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
} hrr_args_hipMemUnmap;

/* hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    int32_t kind;
    uint64_t blob_hash_lo;  /* H2D blob hash lo */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
} hrr_args_hipMemcpy;

/* hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2D;

/* hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpy2DAsync;

/* hipError_t hipMemcpy2DFromArray(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2DFromArray;

/* hipError_t hipMemcpy2DFromArrayAsync(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t width;
    uint64_t height;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpy2DFromArrayAsync;

/* hipError_t hipMemcpy2DToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2DToArray;

/* hipError_t hipMemcpy2DToArrayAsync(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpy2DToArrayAsync;

/* hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t p;
    uint8_t parms_bytes[160];  /* hipMemcpy3DParms inline copy */
    uint64_t blob_hash_lo;  /* H2D blob hash lo (0 if not H2D) */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
    uint64_t d2h_hash_lo;  /* D2H expected-output blob hash lo (0 if not D2H) */
    uint64_t d2h_hash_hi;  /* D2H expected-output blob hash hi */
} hrr_args_hipMemcpy3D;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemcpy3DParms) <= 160, "hrr_args_hipMemcpy3D::parms_bytes[160] too small for hipMemcpy3DParms");
#endif

/* hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms* p, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t p;
    uint64_t stream;
    uint8_t parms_bytes[160];  /* hipMemcpy3DParms inline copy */
    uint64_t blob_hash_lo;  /* H2D blob hash lo (0 if not H2D) */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
    uint64_t d2h_hash_lo;  /* D2H expected-output blob hash lo (0 if not D2H) */
    uint64_t d2h_hash_hi;  /* D2H expected-output blob hash hi */
} hrr_args_hipMemcpy3DAsync;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemcpy3DParms) <= 160, "hrr_args_hipMemcpy3DAsync::parms_bytes[160] too small for hipMemcpy3DParms");
#endif

/* hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    int32_t kind;
    uint64_t stream;
    uint64_t blob_hash_lo;  /* H2D blob hash lo */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
} hrr_args_hipMemcpyAsync;

/* hipError_t hipMemcpyAtoH(void* dst, hipArray_t srcArray, size_t srcOffset, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t srcArray;
    uint64_t srcOffset;
    uint64_t count;
} hrr_args_hipMemcpyAtoH;

/* hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t blob_hash_lo;  /* zero (D2D) */
    uint64_t blob_hash_hi;  /* zero (D2D) */
} hrr_args_hipMemcpyDtoD;

/* hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t stream;
    uint64_t blob_hash_lo;  /* zero (D2D) */
    uint64_t blob_hash_hi;  /* zero (D2D) */
} hrr_args_hipMemcpyDtoDAsync;

/* hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t blob_hash_lo;  /* D2H expected-output blob hash lo */
    uint64_t blob_hash_hi;  /* D2H expected-output blob hash hi */
} hrr_args_hipMemcpyDtoH;

/* hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t stream;
    uint64_t blob_hash_lo;  /* D2H expected-output blob hash lo */
    uint64_t blob_hash_hi;  /* D2H expected-output blob hash hi */
} hrr_args_hipMemcpyDtoHAsync;

/* hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset, size_t count, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t srcArray;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t count;
    int32_t kind;
} hrr_args_hipMemcpyFromArray;

/* hipError_t hipMemcpyFromSymbol(void* dst, const void* symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t symbol;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipMemcpyFromSymbol;

/* hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t symbol;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpyFromSymbolAsync;

/* hipError_t hipMemcpyHtoA(hipArray_t dstArray, size_t dstOffset, const void* srcHost, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dstArray;
    uint64_t dstOffset;
    uint64_t srcHost;
    uint64_t count;
} hrr_args_hipMemcpyHtoA;

/* hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, const void* src, size_t sizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t blob_hash_lo;  /* blob hash lo */
    uint64_t blob_hash_hi;  /* blob hash hi */
} hrr_args_hipMemcpyHtoD;

/* hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, const void* src, size_t sizeBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t stream;
    uint64_t blob_hash_lo;  /* blob hash lo */
    uint64_t blob_hash_hi;  /* blob hash hi */
} hrr_args_hipMemcpyHtoDAsync;

/* hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pCopy;
} hrr_args_hipMemcpyParam2D;

/* hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D* pCopy, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pCopy;
    uint64_t stream;
} hrr_args_hipMemcpyParam2DAsync;

/* hipError_t hipMemcpyPeer(void* dst, int dstDeviceId, const void* src, int srcDeviceId, size_t sizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t dstDeviceId;
    uint64_t src;
    int32_t srcDeviceId;
    uint64_t sizeBytes;
} hrr_args_hipMemcpyPeer;

/* hipError_t hipMemcpyPeerAsync(void* dst, int dstDeviceId, const void* src, int srcDevice, size_t sizeBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t dstDeviceId;
    uint64_t src;
    int32_t srcDevice;
    uint64_t sizeBytes;
    uint64_t stream;
} hrr_args_hipMemcpyPeerAsync;

/* hipError_t hipMemcpyToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t src;
    uint64_t count;
    int32_t kind;
} hrr_args_hipMemcpyToArray;

/* hipError_t hipMemcpyToSymbol(const void* symbol, const void* src, size_t sizeBytes, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipMemcpyToSymbol;

/* hipError_t hipMemcpyToSymbolAsync(const void* symbol, const void* src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpyToSymbolAsync;

/* hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    int32_t kind;
    uint64_t stream;
    uint64_t blob_hash_lo;  /* H2D blob hash lo */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
} hrr_args_hipMemcpyWithStream;

/* hipError_t hipMemset(void* dst, int value, size_t sizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t value;
    uint64_t sizeBytes;
} hrr_args_hipMemset;

/* hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t pitch;
    int32_t value;
    uint64_t width;
    uint64_t height;
} hrr_args_hipMemset2D;

/* hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t pitch;
    int32_t value;
    uint64_t width;
    uint64_t height;
    uint64_t stream;
} hrr_args_hipMemset2DAsync;

/* hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipPitchedPtr */ pitchedDevPtr;
    int32_t value;
    uint64_t /* hipExtent */ extent;
} hrr_args_hipMemset3D;

/* hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipPitchedPtr */ pitchedDevPtr;
    int32_t value;
    uint64_t /* hipExtent */ extent;
    uint64_t stream;
} hrr_args_hipMemset3DAsync;

/* hipError_t hipMemsetAsync(void* dst, int value, size_t sizeBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t value;
    uint64_t sizeBytes;
    uint64_t stream;
} hrr_args_hipMemsetAsync;

/* hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dest;
    uint64_t /* unsigned short */ value;
    uint64_t count;
} hrr_args_hipMemsetD16;

/* hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dest;
    uint64_t /* unsigned short */ value;
    uint64_t count;
    uint64_t stream;
} hrr_args_hipMemsetD16Async;

/* hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dest;
    int32_t value;
    uint64_t count;
} hrr_args_hipMemsetD32;

/* hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t value;
    uint64_t count;
    uint64_t stream;
} hrr_args_hipMemsetD32Async;

/* hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dest;
    uint64_t /* unsigned char */ value;
    uint64_t count;
} hrr_args_hipMemsetD8;

/* hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dest;
    uint64_t /* unsigned char */ value;
    uint64_t count;
    uint64_t stream;
} hrr_args_hipMemsetD8Async;

/* hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle, HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc, unsigned int numMipmapLevels) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pHandle;
    uint64_t pMipmappedArrayDesc;
    uint32_t numMipmapLevels;
} hrr_args_hipMipmappedArrayCreate;

/* hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hMipmappedArray;
} hrr_args_hipMipmappedArrayDestroy;

/* hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pLevelArray;
    uint64_t hMipMappedArray;
    uint32_t level;
} hrr_args_hipMipmappedArrayGetLevel;

/* hipError_t hipModuleGetFunction(hipFunction_t* function, hipModule_t module, const char* kname) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t function;
    uint64_t module;
    uint64_t kname;
} hrr_args_hipModuleGetFunction;

/* hipError_t hipModuleGetFunctionCount(unsigned int* count, hipModule_t module) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t count;
    uint64_t module;
} hrr_args_hipModuleGetFunctionCount;

/* hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes, hipModule_t hmod, const char* name) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptr;
    uint64_t bytes;
    uint64_t hmod;
    uint64_t name;
} hrr_args_hipModuleGetGlobal;

/* hipError_t hipModuleGetTexRef(textureReference** texRef, hipModule_t hmod, const char* name) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t hmod;
    uint64_t name;
} hrr_args_hipModuleGetTexRef;

/* hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, hipStream_t stream, void** kernelParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t f;
    uint32_t gridDimX;
    uint32_t gridDimY;
    uint32_t gridDimZ;
    uint32_t blockDimX;
    uint32_t blockDimY;
    uint32_t blockDimZ;
    uint32_t sharedMemBytes;
    uint64_t stream;
    uint64_t kernelParams;
} hrr_args_hipModuleLaunchCooperativeKernel;

/* hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList, unsigned int numDevices, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t launchParamsList;
    uint32_t numDevices;
    uint32_t flags;
} hrr_args_hipModuleLaunchCooperativeKernelMultiDevice;

/* hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, hipStream_t stream, void** kernelParams, void** extra) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t f;
    uint32_t gridDimX;
    uint32_t gridDimY;
    uint32_t gridDimZ;
    uint32_t blockDimX;
    uint32_t blockDimY;
    uint32_t blockDimZ;
    uint32_t sharedMemBytes;
    uint64_t stream;
    uint64_t kernelParams;
    uint64_t extra;
} hrr_args_hipModuleLaunchKernel;

/* hipError_t hipModuleLoad(hipModule_t* module, const char* fname) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t module;
    uint64_t fname;
    uint64_t co_hash_lo;  /* code object hash lo */
    uint64_t co_hash_hi;  /* code object hash hi */
    uint32_t module_id;  /* sequential module handle ID */
} hrr_args_hipModuleLoad;

/* hipError_t hipModuleLoadData(hipModule_t* module, const void* image) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t module;
    uint64_t image;
    uint64_t co_hash_lo;  /* code object hash lo */
    uint64_t co_hash_hi;  /* code object hash hi */
    uint32_t module_id;  /* sequential module handle ID */
} hrr_args_hipModuleLoadData;

/* hipError_t hipModuleLoadDataEx(hipModule_t* module, const void* image, unsigned int numOptions, hipJitOption* options, void** optionValues) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t module;
    uint64_t image;
    uint32_t numOptions;
    uint64_t options;
    uint64_t optionValues;
    uint64_t co_hash_lo;  /* code object hash lo */
    uint64_t co_hash_hi;  /* code object hash hi */
    uint32_t module_id;  /* sequential module handle ID */
} hrr_args_hipModuleLoadDataEx;

/* hipError_t hipLinkAddData(hipLinkState_t state, hipJitInputType type, void* data, size_t size, const char* name, unsigned int numOptions, hipJitOption* options, void** optionValues) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipLinkState_t */ state;
    uint64_t /* hipJitInputType */ type;
    uint64_t data;
    uint64_t size;
    uint64_t name;
    uint32_t numOptions;
    uint64_t options;
    uint64_t optionValues;
} hrr_args_hipLinkAddData;

/* hipError_t hipLinkAddFile(hipLinkState_t state, hipJitInputType type, const char* path, unsigned int numOptions, hipJitOption* options, void** optionValues) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipLinkState_t */ state;
    uint64_t /* hipJitInputType */ type;
    uint64_t path;
    uint32_t numOptions;
    uint64_t options;
    uint64_t optionValues;
} hrr_args_hipLinkAddFile;

/* hipError_t hipLinkComplete(hipLinkState_t state, void** hipBinOut, size_t* sizeOut) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipLinkState_t */ state;
    uint64_t hipBinOut;
    uint64_t sizeOut;
} hrr_args_hipLinkComplete;

/* hipError_t hipLinkCreate(unsigned int numOptions, hipJitOption* options, void** optionValues, hipLinkState_t* stateOut) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint32_t numOptions;
    uint64_t options;
    uint64_t optionValues;
    uint64_t stateOut;
} hrr_args_hipLinkCreate;

/* hipError_t hipLinkDestroy(hipLinkState_t state) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipLinkState_t */ state;
} hrr_args_hipLinkDestroy;

/* hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t numBlocks;
    uint64_t f;
    int32_t blockSize;
    uint64_t dynSharedMemPerBlk;
} hrr_args_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor;

/* hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t numBlocks;
    uint64_t f;
    int32_t blockSize;
    uint64_t dynSharedMemPerBlk;
    uint32_t flags;
} hrr_args_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;

/* hipError_t hipModuleOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t gridSize;
    uint64_t blockSize;
    uint64_t f;
    uint64_t dynSharedMemPerBlk;
    int32_t blockSizeLimit;
} hrr_args_hipModuleOccupancyMaxPotentialBlockSize;

/* hipError_t hipModuleOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t gridSize;
    uint64_t blockSize;
    uint64_t f;
    uint64_t dynSharedMemPerBlk;
    int32_t blockSizeLimit;
    uint32_t flags;
} hrr_args_hipModuleOccupancyMaxPotentialBlockSizeWithFlags;

/* hipError_t hipModuleUnload(hipModule_t module) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t module;
} hrr_args_hipModuleUnload;

/* hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* f, int numBlocks, int blockSize) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dynamicSmemSize;
    uint64_t f;
    int32_t numBlocks;
    int32_t blockSize;
} hrr_args_hipOccupancyAvailableDynamicSMemPerBlock;

/* hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t numBlocks;
    uint64_t f;
    int32_t blockSize;
    uint64_t dynSharedMemPerBlk;
} hrr_args_hipOccupancyMaxActiveBlocksPerMultiprocessor;

/* hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t numBlocks;
    uint64_t f;
    int32_t blockSize;
    uint64_t dynSharedMemPerBlk;
    uint32_t flags;
} hrr_args_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;

/* hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize, const void* f, size_t dynSharedMemPerBlk, int blockSizeLimit) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t gridSize;
    uint64_t blockSize;
    uint64_t f;
    uint64_t dynSharedMemPerBlk;
    int32_t blockSizeLimit;
} hrr_args_hipOccupancyMaxPotentialBlockSize;

/* hipError_t hipOccupancyMaxActiveClusters(int* numClusters, const void* f, const hipLaunchConfig_t* launchConfig) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t numClusters;
    uint64_t f;
    uint64_t launchConfig;
} hrr_args_hipOccupancyMaxActiveClusters;

/* hipError_t hipOccupancyMaxPotentialClusterSize(int* clusterSize, const void* f, const hipLaunchConfig_t* config) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t clusterSize;
    uint64_t f;
    uint64_t config;
} hrr_args_hipOccupancyMaxPotentialClusterSize;

/* hipError_t hipPeekAtLastError() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipPeekAtLastError;

/* hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute, hipDeviceptr_t ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t data;
    uint64_t /* hipPointer_attribute */ attribute;
    uint64_t ptr;
} hrr_args_hipPointerGetAttribute;

/* hipError_t hipPointerGetAttributes(hipPointerAttribute_t* attributes, const void* ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t attributes;
    uint64_t ptr;
} hrr_args_hipPointerGetAttributes;

/* hipError_t hipPointerSetAttribute(const void* value, hipPointer_attribute attribute, hipDeviceptr_t ptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t value;
    uint64_t /* hipPointer_attribute */ attribute;
    uint64_t ptr;
} hrr_args_hipPointerSetAttribute;

/* hipError_t hipProfilerStart() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipProfilerStart;

/* hipError_t hipProfilerStop() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipProfilerStop;

/* hipError_t hipRuntimeGetVersion(int* runtimeVersion) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t runtimeVersion;
} hrr_args_hipRuntimeGetVersion;

/* hipError_t hipSetDevice(int deviceId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    int32_t deviceId;
} hrr_args_hipSetDevice;

/* hipError_t hipSetDeviceFlags(unsigned flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint32_t flags;
} hrr_args_hipSetDeviceFlags;

/* hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t arg;
    uint64_t size;
    uint64_t offset;
} hrr_args_hipSetupArgument;

/* hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray, const hipExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t extSemArray;
    uint64_t paramsArray;
    uint32_t numExtSems;
    uint64_t stream;
} hrr_args_hipSignalExternalSemaphoresAsync;

/* hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void* userData, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t /* hipStreamCallback_t */ callback;
    uint64_t userData;
    uint32_t flags;
} hrr_args_hipStreamAddCallback;

/* hipError_t hipStreamAttachMemAsync(hipStream_t stream, void* dev_ptr, size_t length, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t dev_ptr;
    uint64_t length;
    uint32_t flags;
} hrr_args_hipStreamAttachMemAsync;

/* hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    int32_t mode;
} hrr_args_hipStreamBeginCapture;

/* hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
} hrr_args_hipStreamCopyAttributes;

/* hipError_t hipStreamCreate(hipStream_t* stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipStreamCreate;

/* hipError_t hipStreamCreateWithFlags(hipStream_t* stream, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint32_t flags;
} hrr_args_hipStreamCreateWithFlags;

/* hipError_t hipStreamCreateWithPriority(hipStream_t* stream, unsigned int flags, int priority) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint32_t flags;
    int32_t priority;
} hrr_args_hipStreamCreateWithPriority;

/* hipError_t hipStreamDestroy(hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipStreamDestroy;

/* hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t* pGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t pGraph;
} hrr_args_hipStreamEndCapture;

/* hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus, unsigned long long* pId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t pCaptureStatus;
    uint64_t pId;
} hrr_args_hipStreamGetCaptureInfo;

/* hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, hipGraph_t* graph_out, const hipGraphNode_t** dependencies_out, size_t* numDependencies_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t captureStatus_out;
    uint64_t id_out;
    uint64_t graph_out;
    uint64_t dependencies_out;
    uint64_t numDependencies_out;
} hrr_args_hipStreamGetCaptureInfo_v2;

/* hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t* device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t device;
} hrr_args_hipStreamGetDevice;

/* hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t flags;
} hrr_args_hipStreamGetFlags;

/* hipError_t hipStreamGetId(hipStream_t stream, unsigned long long* streamId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t streamId;
} hrr_args_hipStreamGetId;

/* hipError_t hipStreamGetPriority(hipStream_t stream, int* priority) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t priority;
} hrr_args_hipStreamGetPriority;

/* hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t pCaptureStatus;
} hrr_args_hipStreamIsCapturing;

/* hipError_t hipStreamQuery(hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipStreamQuery;

/* hipError_t hipStreamSynchronize(hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipStreamSynchronize;

/* hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t dependencies;
    uint64_t numDependencies;
    uint32_t flags;
} hrr_args_hipStreamUpdateCaptureDependencies;

/* hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t event;
    uint32_t flags;
} hrr_args_hipStreamWaitEvent;

/* hipError_t hipStreamWaitValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags, uint32_t mask) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t ptr;
    uint32_t value;
    uint32_t flags;
    uint32_t mask;
} hrr_args_hipStreamWaitValue32;

/* hipError_t hipStreamWaitValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags, uint64_t mask) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t ptr;
    uint64_t value;
    uint32_t flags;
    uint64_t mask;
} hrr_args_hipStreamWaitValue64;

/* hipError_t hipStreamWriteValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t ptr;
    uint32_t value;
    uint32_t flags;
} hrr_args_hipStreamWriteValue32;

/* hipError_t hipStreamWriteValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t ptr;
    uint64_t value;
    uint32_t flags;
} hrr_args_hipStreamWriteValue64;

/* hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count, hipStreamBatchMemOpParams* paramArray, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint32_t count;
    uint64_t paramArray;
    uint32_t flags;
} hrr_args_hipStreamBatchMemOp;

/* hipError_t hipTexObjectCreate(hipTextureObject_t* pTexObject, const HIP_RESOURCE_DESC* pResDesc, const HIP_TEXTURE_DESC* pTexDesc, const HIP_RESOURCE_VIEW_DESC* pResViewDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pTexObject;
    uint64_t pResDesc;
    uint64_t pTexDesc;
    uint64_t pResViewDesc;
} hrr_args_hipTexObjectCreate;

/* hipError_t hipTexObjectDestroy(hipTextureObject_t texObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texObject;
} hrr_args_hipTexObjectDestroy;

/* hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC* pResDesc, hipTextureObject_t texObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pResDesc;
    uint64_t texObject;
} hrr_args_hipTexObjectGetResourceDesc;

/* hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc, hipTextureObject_t texObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pResViewDesc;
    uint64_t texObject;
} hrr_args_hipTexObjectGetResourceViewDesc;

/* hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC* pTexDesc, hipTextureObject_t texObject) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pTexDesc;
    uint64_t texObject;
} hrr_args_hipTexObjectGetTextureDesc;

/* hipError_t hipTexRefGetAddress(hipDeviceptr_t* dev_ptr, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dev_ptr;
    uint64_t texRef;
} hrr_args_hipTexRefGetAddress;

/* hipError_t hipTexRefGetAddressMode(enum hipTextureAddressMode* pam, const textureReference* texRef, int dim) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pam;
    uint64_t texRef;
    int32_t dim;
} hrr_args_hipTexRefGetAddressMode;

/* hipError_t hipTexRefGetFilterMode(enum hipTextureFilterMode* pfm, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pfm;
    uint64_t texRef;
} hrr_args_hipTexRefGetFilterMode;

/* hipError_t hipTexRefGetFlags(unsigned int* pFlags, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pFlags;
    uint64_t texRef;
} hrr_args_hipTexRefGetFlags;

/* hipError_t hipTexRefGetFormat(hipArray_Format* pFormat, int* pNumChannels, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pFormat;
    uint64_t pNumChannels;
    uint64_t texRef;
} hrr_args_hipTexRefGetFormat;

/* hipError_t hipTexRefGetMaxAnisotropy(int* pmaxAnsio, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pmaxAnsio;
    uint64_t texRef;
} hrr_args_hipTexRefGetMaxAnisotropy;

/* hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t* pArray, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pArray;
    uint64_t texRef;
} hrr_args_hipTexRefGetMipMappedArray;

/* hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pfm;
    uint64_t texRef;
} hrr_args_hipTexRefGetMipmapFilterMode;

/* hipError_t hipTexRefGetMipmapLevelBias(float* pbias, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pbias;
    uint64_t texRef;
} hrr_args_hipTexRefGetMipmapLevelBias;

/* hipError_t hipTexRefGetMipmapLevelClamp(float* pminMipmapLevelClamp, float* pmaxMipmapLevelClamp, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pminMipmapLevelClamp;
    uint64_t pmaxMipmapLevelClamp;
    uint64_t texRef;
} hrr_args_hipTexRefGetMipmapLevelClamp;

/* hipError_t hipTexRefSetAddress(size_t* ByteOffset, textureReference* texRef, hipDeviceptr_t dptr, size_t bytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ByteOffset;
    uint64_t texRef;
    uint64_t dptr;
    uint64_t bytes;
} hrr_args_hipTexRefSetAddress;

/* hipError_t hipTexRefSetAddress2D(textureReference* texRef, const HIP_ARRAY_DESCRIPTOR* desc, hipDeviceptr_t dptr, size_t Pitch) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t desc;
    uint64_t dptr;
    uint64_t Pitch;
} hrr_args_hipTexRefSetAddress2D;

/* hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim, enum hipTextureAddressMode am) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    int32_t dim;
    uint64_t /* enum hipTextureAddressMode */ am;
} hrr_args_hipTexRefSetAddressMode;

/* hipError_t hipTexRefSetArray(textureReference* tex, hipArray_const_t array, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t tex;
    uint64_t array;
    uint32_t flags;
} hrr_args_hipTexRefSetArray;

/* hipError_t hipTexRefSetBorderColor(textureReference* texRef, float* pBorderColor) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t pBorderColor;
} hrr_args_hipTexRefSetBorderColor;

/* hipError_t hipTexRefSetFilterMode(textureReference* texRef, enum hipTextureFilterMode fm) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t /* enum hipTextureFilterMode */ fm;
} hrr_args_hipTexRefSetFilterMode;

/* hipError_t hipTexRefSetFlags(textureReference* texRef, unsigned int Flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint32_t Flags;
} hrr_args_hipTexRefSetFlags;

/* hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt, int NumPackedComponents) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t /* hipArray_Format */ fmt;
    int32_t NumPackedComponents;
} hrr_args_hipTexRefSetFormat;

/* hipError_t hipTexRefSetMaxAnisotropy(textureReference* texRef, unsigned int maxAniso) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint32_t maxAniso;
} hrr_args_hipTexRefSetMaxAnisotropy;

/* hipError_t hipTexRefSetMipmapFilterMode(textureReference* texRef, enum hipTextureFilterMode fm) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t /* enum hipTextureFilterMode */ fm;
} hrr_args_hipTexRefSetMipmapFilterMode;

/* hipError_t hipTexRefSetMipmapLevelBias(textureReference* texRef, float bias) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    float bias;
} hrr_args_hipTexRefSetMipmapLevelBias;

/* hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    float minMipMapLevelClamp;
    float maxMipMapLevelClamp;
} hrr_args_hipTexRefSetMipmapLevelClamp;

/* hipError_t hipTexRefSetMipmappedArray(textureReference* texRef, struct hipMipmappedArray* mipmappedArray, unsigned int Flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t texRef;
    uint64_t mipmappedArray;
    uint32_t Flags;
} hrr_args_hipTexRefSetMipmappedArray;

/* hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mode;
} hrr_args_hipThreadExchangeStreamCaptureMode;

/* hipError_t hipUnbindTexture(const textureReference* tex) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t tex;
} hrr_args_hipUnbindTexture;

/* hipError_t hipUserObjectCreate(hipUserObject_t* object_out, void* ptr, hipHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t object_out;
    uint64_t ptr;
    uint64_t /* hipHostFn_t */ destroy;
    uint32_t initialRefcount;
    uint32_t flags;
} hrr_args_hipUserObjectCreate;

/* hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t object;
    uint32_t count;
} hrr_args_hipUserObjectRelease;

/* hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t object;
    uint32_t count;
} hrr_args_hipUserObjectRetain;

/* hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray, const hipExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t extSemArray;
    uint64_t paramsArray;
    uint32_t numExtSems;
    uint64_t stream;
} hrr_args_hipWaitExternalSemaphoresAsync;

/* hipError_t hipMemcpy_spt(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    int32_t kind;
} hrr_args_hipMemcpy_spt;

/* hipError_t hipMemcpyToSymbol_spt(const void* symbol, const void* src, size_t sizeBytes, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipMemcpyToSymbol_spt;

/* hipError_t hipMemcpyFromSymbol_spt(void* dst, const void* symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t symbol;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
} hrr_args_hipMemcpyFromSymbol_spt;

/* hipError_t hipMemcpy2D_spt(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2D_spt;

/* hipError_t hipMemcpy2DFromArray_spt(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2DFromArray_spt;

/* hipError_t hipMemcpy3D_spt(const struct hipMemcpy3DParms* p) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t p;
    uint8_t parms_bytes[160];  /* hipMemcpy3DParms inline copy */
    uint64_t blob_hash_lo;  /* H2D blob hash lo (0 if not H2D) */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
    uint64_t d2h_hash_lo;  /* D2H expected-output blob hash lo (0 if not D2H) */
    uint64_t d2h_hash_hi;  /* D2H expected-output blob hash hi */
} hrr_args_hipMemcpy3D_spt;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemcpy3DParms) <= 160, "hrr_args_hipMemcpy3D_spt::parms_bytes[160] too small for hipMemcpy3DParms");
#endif

/* hipError_t hipMemset_spt(void* dst, int value, size_t sizeBytes) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t value;
    uint64_t sizeBytes;
} hrr_args_hipMemset_spt;

/* hipError_t hipMemsetAsync_spt(void* dst, int value, size_t sizeBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    int32_t value;
    uint64_t sizeBytes;
    uint64_t stream;
} hrr_args_hipMemsetAsync_spt;

/* hipError_t hipMemset2D_spt(void* dst, size_t pitch, int value, size_t width, size_t height) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t pitch;
    int32_t value;
    uint64_t width;
    uint64_t height;
} hrr_args_hipMemset2D_spt;

/* hipError_t hipMemset2DAsync_spt(void* dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t pitch;
    int32_t value;
    uint64_t width;
    uint64_t height;
    uint64_t stream;
} hrr_args_hipMemset2DAsync_spt;

/* hipError_t hipMemset3DAsync_spt(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipPitchedPtr */ pitchedDevPtr;
    int32_t value;
    uint64_t /* hipExtent */ extent;
    uint64_t stream;
} hrr_args_hipMemset3DAsync_spt;

/* hipError_t hipMemset3D_spt(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipPitchedPtr */ pitchedDevPtr;
    int32_t value;
    uint64_t /* hipExtent */ extent;
} hrr_args_hipMemset3D_spt;

/* hipError_t hipMemcpyAsync_spt(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t sizeBytes;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpyAsync_spt;

/* hipError_t hipMemcpy3DAsync_spt(const hipMemcpy3DParms* p, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t p;
    uint64_t stream;
    uint8_t parms_bytes[160];  /* hipMemcpy3DParms inline copy */
    uint64_t blob_hash_lo;  /* H2D blob hash lo (0 if not H2D) */
    uint64_t blob_hash_hi;  /* H2D blob hash hi */
    uint64_t d2h_hash_lo;  /* D2H expected-output blob hash lo (0 if not D2H) */
    uint64_t d2h_hash_hi;  /* D2H expected-output blob hash hi */
} hrr_args_hipMemcpy3DAsync_spt;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipMemcpy3DParms) <= 160, "hrr_args_hipMemcpy3DAsync_spt::parms_bytes[160] too small for hipMemcpy3DParms");
#endif

/* hipError_t hipMemcpy2DAsync_spt(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpy2DAsync_spt;

/* hipError_t hipMemcpyFromSymbolAsync_spt(void* dst, const void* symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t symbol;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpyFromSymbolAsync_spt;

/* hipError_t hipMemcpyToSymbolAsync_spt(const void* symbol, const void* src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t src;
    uint64_t sizeBytes;
    uint64_t offset;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpyToSymbolAsync_spt;

/* hipError_t hipMemcpyFromArray_spt(void* dst, hipArray_const_t src, size_t wOffsetSrc, size_t hOffset, size_t count, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t src;
    uint64_t wOffsetSrc;
    uint64_t hOffset;
    uint64_t count;
    int32_t kind;
} hrr_args_hipMemcpyFromArray_spt;

/* hipError_t hipMemcpy2DToArray_spt(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2DToArray_spt;

/* hipError_t hipMemcpy2DFromArrayAsync_spt(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dpitch;
    uint64_t src;
    uint64_t wOffsetSrc;
    uint64_t hOffsetSrc;
    uint64_t width;
    uint64_t height;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpy2DFromArrayAsync_spt;

/* hipError_t hipMemcpy2DToArrayAsync_spt(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t wOffset;
    uint64_t hOffset;
    uint64_t src;
    uint64_t spitch;
    uint64_t width;
    uint64_t height;
    int32_t kind;
    uint64_t stream;
} hrr_args_hipMemcpy2DToArrayAsync_spt;

/* hipError_t hipStreamQuery_spt(hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipStreamQuery_spt;

/* hipError_t hipStreamSynchronize_spt(hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipStreamSynchronize_spt;

/* hipError_t hipStreamGetPriority_spt(hipStream_t stream, int* priority) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t priority;
} hrr_args_hipStreamGetPriority_spt;

/* hipError_t hipStreamWaitEvent_spt(hipStream_t stream, hipEvent_t event, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t event;
    uint32_t flags;
} hrr_args_hipStreamWaitEvent_spt;

/* hipError_t hipStreamGetFlags_spt(hipStream_t stream, unsigned int* flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t flags;
} hrr_args_hipStreamGetFlags_spt;

/* hipError_t hipStreamAddCallback_spt(hipStream_t stream, hipStreamCallback_t callback, void* userData, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t /* hipStreamCallback_t */ callback;
    uint64_t userData;
    uint32_t flags;
} hrr_args_hipStreamAddCallback_spt;

/* hipError_t hipEventRecord_spt(hipEvent_t event, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
    uint64_t stream;
} hrr_args_hipEventRecord_spt;

/* hipError_t hipLaunchCooperativeKernel_spt(const void* f, dim3 gridDim, dim3 blockDim, void** kernelParams, uint32_t sharedMemBytes, hipStream_t hStream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t f;
    uint32_t gridDim_x;
    uint32_t gridDim_y;
    uint32_t gridDim_z;
    uint32_t blockDim_x;
    uint32_t blockDim_y;
    uint32_t blockDim_z;
    uint64_t kernelParams;
    uint32_t sharedMemBytes;
    uint64_t hStream;
} hrr_args_hipLaunchCooperativeKernel_spt;

/* hipError_t hipLaunchKernel_spt(const void* function_address, dim3 numBlocks, dim3 dimBlocks, void** args, size_t sharedMemBytes, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t function_address;
    uint32_t numBlocks_x;
    uint32_t numBlocks_y;
    uint32_t numBlocks_z;
    uint32_t dimBlocks_x;
    uint32_t dimBlocks_y;
    uint32_t dimBlocks_z;
    uint64_t args;
    uint64_t sharedMemBytes;
    uint64_t stream;
} hrr_args_hipLaunchKernel_spt;

/* hipError_t hipGraphLaunch_spt(hipGraphExec_t graphExec, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graphExec;
    uint64_t stream;
} hrr_args_hipGraphLaunch_spt;

/* hipError_t hipStreamBeginCapture_spt(hipStream_t stream, hipStreamCaptureMode mode) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    int32_t mode;
} hrr_args_hipStreamBeginCapture_spt;

/* hipError_t hipStreamEndCapture_spt(hipStream_t stream, hipGraph_t* pGraph) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t pGraph;
} hrr_args_hipStreamEndCapture_spt;

/* hipError_t hipStreamIsCapturing_spt(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t pCaptureStatus;
} hrr_args_hipStreamIsCapturing_spt;

/* hipError_t hipStreamGetCaptureInfo_spt(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus, unsigned long long* pId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t pCaptureStatus;
    uint64_t pId;
} hrr_args_hipStreamGetCaptureInfo_spt;

/* hipError_t hipStreamGetCaptureInfo_v2_spt(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, hipGraph_t* graph_out, const hipGraphNode_t** dependencies_out, size_t* numDependencies_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t captureStatus_out;
    uint64_t id_out;
    uint64_t graph_out;
    uint64_t dependencies_out;
    uint64_t numDependencies_out;
} hrr_args_hipStreamGetCaptureInfo_v2_spt;

/* hipError_t hipLaunchHostFunc_spt(hipStream_t stream, hipHostFn_t fn, void* userData) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t /* hipHostFn_t */ fn;
    uint64_t userData;
} hrr_args_hipLaunchHostFunc_spt;

/* hipChannelFormatDesc hipCreateChannelDesc(int x, int y, int z, int w, hipChannelFormatKind f) */
typedef struct {
    hrr_event_header hdr;
    uint64_t /* hipChannelFormatDesc */ ret;
    int32_t x;
    int32_t y;
    int32_t z;
    int32_t w;
    int32_t f;
} hrr_args_hipCreateChannelDesc;

/* hipError_t hipExtModuleLaunchKernel(hipFunction_t f, uint32_t globalWorkSizeX, uint32_t globalWorkSizeY, uint32_t globalWorkSizeZ, uint32_t localWorkSizeX, uint32_t localWorkSizeY, uint32_t localWorkSizeZ, size_t sharedMemBytes, hipStream_t hStream, void** kernelParams, void** extra, hipEvent_t startEvent, hipEvent_t stopEvent, uint32_t flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t f;
    uint32_t globalWorkSizeX;
    uint32_t globalWorkSizeY;
    uint32_t globalWorkSizeZ;
    uint32_t localWorkSizeX;
    uint32_t localWorkSizeY;
    uint32_t localWorkSizeZ;
    uint64_t sharedMemBytes;
    uint64_t hStream;
    uint64_t kernelParams;
    uint64_t extra;
    uint64_t startEvent;
    uint64_t stopEvent;
    uint32_t flags;
} hrr_args_hipExtModuleLaunchKernel;

/* hipError_t hipHccModuleLaunchKernel(hipFunction_t f, uint32_t globalWorkSizeX, uint32_t globalWorkSizeY, uint32_t globalWorkSizeZ, uint32_t localWorkSizeX, uint32_t localWorkSizeY, uint32_t localWorkSizeZ, size_t sharedMemBytes, hipStream_t hStream, void** kernelParams, void** extra, hipEvent_t startEvent, hipEvent_t stopEvent) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t f;
    uint32_t globalWorkSizeX;
    uint32_t globalWorkSizeY;
    uint32_t globalWorkSizeZ;
    uint32_t localWorkSizeX;
    uint32_t localWorkSizeY;
    uint32_t localWorkSizeZ;
    uint64_t sharedMemBytes;
    uint64_t hStream;
    uint64_t kernelParams;
    uint64_t extra;
    uint64_t startEvent;
    uint64_t stopEvent;
} hrr_args_hipHccModuleLaunchKernel;

/* int hipGetStreamDeviceId(hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
} hrr_args_hipGetStreamDeviceId;

/* hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph, const hipGraphNode_t* dependencies, size_t numDependencies, const hipMemsetParams* memsetParams, hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t phGraphNode;
    uint64_t hGraph;
    uint64_t dependencies;
    uint64_t numDependencies;
    uint64_t memsetParams;
    uint64_t ctx;
} hrr_args_hipDrvGraphAddMemsetNode;

/* hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t nodeParams;
} hrr_args_hipGraphAddExternalSemaphoresWaitNode;

/* hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t nodeParams;
} hrr_args_hipGraphAddExternalSemaphoresSignalNode;

/* hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipGraphExternalSemaphoresSignalNodeSetParams;

/* hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipGraphExternalSemaphoresWaitNodeSetParams;

/* hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t params_out;
} hrr_args_hipGraphExternalSemaphoresSignalNodeGetParams;

/* hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t params_out;
} hrr_args_hipGraphExternalSemaphoresWaitNodeGetParams;

/* hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipGraphExecExternalSemaphoresSignalNodeSetParams;

/* hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipGraphExecExternalSemaphoresWaitNodeSetParams;

/* hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies, size_t numDependencies, hipGraphNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphNode;
    uint64_t graph;
    uint64_t pDependencies;
    uint64_t numDependencies;
    uint64_t nodeParams;
} hrr_args_hipGraphAddNode;

/* hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph, hipGraphInstantiateParams* instantiateParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pGraphExec;
    uint64_t graph;
    uint64_t instantiateParams;
} hrr_args_hipGraphInstantiateWithParams;

/* hipError_t hipExtGetLastError() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipExtGetLastError;

/* hipError_t hipTexRefGetBorderColor(float* pBorderColor, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pBorderColor;
    uint64_t texRef;
} hrr_args_hipTexRefGetBorderColor;

/* hipError_t hipTexRefGetArray(hipArray_t* pArray, const textureReference* texRef) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pArray;
    uint64_t texRef;
} hrr_args_hipTexRefGetArray;

/* hipError_t hipGetProcAddress(const char* symbol, void** pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult* symbolStatus) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t pfn;
    int32_t hipVersion;
    uint64_t flags;
    uint64_t symbolStatus;
} hrr_args_hipGetProcAddress;

/* hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph, const hipGraphNode_t* dependencies, const hipGraphEdgeData* dependencyData, size_t numDependencies, hipStreamCaptureMode mode) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t graph;
    uint64_t dependencies;
    uint64_t dependencyData;
    uint64_t numDependencies;
    int32_t mode;
} hrr_args_hipStreamBeginCaptureToGraph;

/* hipError_t hipGetFuncBySymbol(hipFunction_t* functionPtr, const void* symbolPtr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t functionPtr;
    uint64_t symbolPtr;
} hrr_args_hipGetFuncBySymbol;

/* hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph, const hipGraphNode_t* dependencies, size_t numDependencies, hipDeviceptr_t dptr) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t phGraphNode;
    uint64_t hGraph;
    uint64_t dependencies;
    uint64_t numDependencies;
    uint64_t dptr;
} hrr_args_hipDrvGraphAddMemFreeNode;

/* hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const HIP_MEMCPY3D* copyParams, hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t copyParams;
    uint64_t ctx;
} hrr_args_hipDrvGraphExecMemcpyNodeSetParams;

/* hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipMemsetParams* memsetParams, hipCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t memsetParams;
    uint64_t ctx;
} hrr_args_hipDrvGraphExecMemsetNodeSetParams;

/* hipError_t hipSetValidDevices(int* device_arr, int len) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device_arr;
    int32_t len;
} hrr_args_hipSetValidDevices;

/* hipError_t hipMemcpyAtoD(hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset, size_t ByteCount) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dstDevice;
    uint64_t srcArray;
    uint64_t srcOffset;
    uint64_t ByteCount;
} hrr_args_hipMemcpyAtoD;

/* hipError_t hipMemcpyDtoA(hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice, size_t ByteCount) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dstArray;
    uint64_t dstOffset;
    uint64_t srcDevice;
    uint64_t ByteCount;
} hrr_args_hipMemcpyDtoA;

/* hipError_t hipMemcpyAtoA(hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray, size_t srcOffset, size_t ByteCount) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dstArray;
    uint64_t dstOffset;
    uint64_t srcArray;
    uint64_t srcOffset;
    uint64_t ByteCount;
} hrr_args_hipMemcpyAtoA;

/* hipError_t hipMemcpyAtoHAsync(void* dstHost, hipArray_t srcArray, size_t srcOffset, size_t ByteCount, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dstHost;
    uint64_t srcArray;
    uint64_t srcOffset;
    uint64_t ByteCount;
    uint64_t stream;
} hrr_args_hipMemcpyAtoHAsync;

/* hipError_t hipMemcpyHtoAAsync(hipArray_t dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dstArray;
    uint64_t dstOffset;
    uint64_t srcHost;
    uint64_t ByteCount;
    uint64_t stream;
} hrr_args_hipMemcpyHtoAAsync;

/* hipError_t hipMemcpy2DArrayToArray(hipArray_t dst, size_t wOffsetDst, size_t hOffsetDst, hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, hipMemcpyKind kind) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t wOffsetDst;
    uint64_t hOffsetDst;
    uint64_t src;
    uint64_t wOffsetSrc;
    uint64_t hOffsetSrc;
    uint64_t width;
    uint64_t height;
    int32_t kind;
} hrr_args_hipMemcpy2DArrayToArray;

/* hipError_t hipGraphExecGetFlags(hipGraphExec_t graphExec, unsigned long long* flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graphExec;
    uint64_t flags;
} hrr_args_hipGraphExecGetFlags;

/* hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t node;
    uint64_t nodeParams;
} hrr_args_hipGraphNodeSetParams;

/* hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node, hipGraphNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t graphExec;
    uint64_t node;
    uint64_t nodeParams;
} hrr_args_hipGraphExecNodeSetParams;

/* hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc* mipmapDesc) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t mipmap;
    uint64_t extMem;
    uint64_t mipmapDesc;
} hrr_args_hipExternalMemoryGetMappedMipmappedArray;

/* hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipDrvGraphMemcpyNodeGetParams;

/* hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipDrvGraphMemcpyNodeSetParams;

/* hipError_t hipExtHostAlloc(void** ptr, size_t size, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ptr;
    uint64_t size;
    uint32_t flags;
} hrr_args_hipExtHostAlloc;

/* hipError_t hipDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const hipChannelFormatDesc* fmtDesc, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t maxWidthInElements;
    uint64_t fmtDesc;
    int32_t device;
} hrr_args_hipDeviceGetTexture1DLinearMaxWidth;

/* hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph, const hipGraphNode_t* dependencies, size_t numDependencies, const hipBatchMemOpNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t phGraphNode;
    uint64_t hGraph;
    uint64_t dependencies;
    uint64_t numDependencies;
    uint64_t nodeParams;
} hrr_args_hipGraphAddBatchMemOpNode;

/* hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams* nodeParams_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t nodeParams_out;
} hrr_args_hipGraphBatchMemOpNodeGetParams;

/* hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipGraphBatchMemOpNodeSetParams;

/* hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipBatchMemOpNodeParams* nodeParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hGraphExec;
    uint64_t hNode;
    uint64_t nodeParams;
} hrr_args_hipGraphExecBatchMemOpNodeSetParams;

/* hipError_t hipEventRecordWithFlags(hipEvent_t event, hipStream_t stream, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t event;
    uint64_t stream;
    uint32_t flags;
} hrr_args_hipEventRecordWithFlags;

/* hipError_t hipLaunchKernelExC(const hipLaunchConfig_t* config, const void* fPtr, void** args) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t config;
    uint64_t fPtr;
    uint64_t args;
} hrr_args_hipLaunchKernelExC;

/* hipError_t hipDrvLaunchKernelEx(const HIP_LAUNCH_CONFIG* config, hipFunction_t f, void** params, void** extra) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t config;
    uint64_t f;
    uint64_t params;
    uint64_t extra;
} hrr_args_hipDrvLaunchKernelEx;

/* hipError_t hipMemGetHandleForAddressRange(void* handle, hipDeviceptr_t dptr, size_t size, hipMemRangeHandleType handleType, unsigned long long flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t handle;
    uint64_t dptr;
    uint64_t size;
    uint64_t /* hipMemRangeHandleType */ handleType;
    uint64_t flags;
} hrr_args_hipMemGetHandleForAddressRange;

/* hipError_t hipMemsetD2D8(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dstPitch;
    uint64_t /* unsigned char */ value;
    uint64_t width;
    uint64_t height;
} hrr_args_hipMemsetD2D8;

/* hipError_t hipMemsetD2D8Async(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dstPitch;
    uint64_t /* unsigned char */ value;
    uint64_t width;
    uint64_t height;
    uint64_t stream;
} hrr_args_hipMemsetD2D8Async;

/* hipError_t hipMemsetD2D16(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dstPitch;
    uint64_t /* unsigned short */ value;
    uint64_t width;
    uint64_t height;
} hrr_args_hipMemsetD2D16;

/* hipError_t hipMemsetD2D16Async(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dstPitch;
    uint64_t /* unsigned short */ value;
    uint64_t width;
    uint64_t height;
    uint64_t stream;
} hrr_args_hipMemsetD2D16Async;

/* hipError_t hipMemsetD2D32(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dstPitch;
    uint32_t value;
    uint64_t width;
    uint64_t height;
} hrr_args_hipMemsetD2D32;

/* hipError_t hipMemsetD2D32Async(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dst;
    uint64_t dstPitch;
    uint32_t value;
    uint64_t width;
    uint64_t height;
    uint64_t stream;
} hrr_args_hipMemsetD2D32Async;

/* hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr, const hipStreamAttrValue* value) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t /* hipStreamAttrID */ attr;
    uint64_t value;
    uint8_t stream_attr_bytes[64];  /* hipStreamAttrValue inline copy */
} hrr_args_hipStreamSetAttribute;
#ifdef HIP_INCLUDE_HIP_HIP_RUNTIME_H
static_assert(sizeof(hipStreamAttrValue) <= 64, "hrr_args_hipStreamSetAttribute::stream_attr_bytes[64] too small for hipStreamAttrValue");
#endif

/* hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr, hipStreamAttrValue* value_out) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t /* hipStreamAttrID */ attr;
    uint64_t value_out;
} hrr_args_hipStreamGetAttribute;

/* hipError_t hipModuleLoadFatBinary(hipModule_t* module, const void* fatbin) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t module;
    uint64_t fatbin;
} hrr_args_hipModuleLoadFatBinary;

/* hipError_t hipMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count, hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs, size_t* failIdx, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dsts;
    uint64_t srcs;
    uint64_t sizes;
    uint64_t count;
    uint64_t attrs;
    uint64_t attrsIdxs;
    uint64_t numAttrs;
    uint64_t failIdx;
    uint64_t stream;
} hrr_args_hipMemcpyBatchAsync;

/* hipError_t hipMemcpy3DBatchAsync(size_t numOps, struct hipMemcpy3DBatchOp* opList, size_t* failIdx, unsigned long long flags, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t numOps;
    uint64_t opList;
    uint64_t failIdx;
    uint64_t flags;
    uint64_t stream;
} hrr_args_hipMemcpy3DBatchAsync;

/* hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t p;
} hrr_args_hipMemcpy3DPeer;

/* hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms* p, hipStream_t stream) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t p;
    uint64_t stream;
} hrr_args_hipMemcpy3DPeerAsync;

/* hipError_t hipGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags, hipDriverEntryPointQueryResult* status) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t funcPtr;
    uint64_t flags;
    uint64_t status;
} hrr_args_hipGetDriverEntryPoint;

/* hipError_t hipGetDriverEntryPoint_spt(const char* symbol, void** funcPtr, unsigned long long flags, hipDriverEntryPointQueryResult* status) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t funcPtr;
    uint64_t flags;
    uint64_t status;
} hrr_args_hipGetDriverEntryPoint_spt;

/* hipError_t hipLibraryLoadData(hipLibrary_t* library, const void* code, hipJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, hipLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t library;
    uint64_t code;
    uint64_t jitOptions;
    uint64_t jitOptionsValues;
    uint32_t numJitOptions;
    uint64_t libraryOptions;
    uint64_t libraryOptionValues;
    uint32_t numLibraryOptions;
} hrr_args_hipLibraryLoadData;

/* hipError_t hipLibraryLoadFromFile(hipLibrary_t* library, const char* fileName, hipJitOption* jitOptions, void** jitOptionsValues, unsigned int numJitOptions, hipLibraryOption* libraryOptions, void** libraryOptionValues, unsigned int numLibraryOptions) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t library;
    uint64_t fileName;
    uint64_t jitOptions;
    uint64_t jitOptionsValues;
    uint32_t numJitOptions;
    uint64_t libraryOptions;
    uint64_t libraryOptionValues;
    uint32_t numLibraryOptions;
} hrr_args_hipLibraryLoadFromFile;

/* hipError_t hipLibraryUnload(hipLibrary_t library) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t library;
} hrr_args_hipLibraryUnload;

/* hipError_t hipLibraryGetKernel(hipKernel_t* pKernel, hipLibrary_t library, const char* name) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pKernel;
    uint64_t library;
    uint64_t name;
} hrr_args_hipLibraryGetKernel;

/* hipError_t hipLibraryGetKernelCount(unsigned int* count, hipLibrary_t library) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t count;
    uint64_t library;
} hrr_args_hipLibraryGetKernelCount;

/* hipError_t hipLibraryGetGlobal(void** dptr, size_t* bytes, hipLibrary_t library, const char* name) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptr;
    uint64_t bytes;
    uint64_t library;
    uint64_t name;
} hrr_args_hipLibraryGetGlobal;

/* hipError_t hipLibraryGetManaged(void** dptr, size_t* bytes, hipLibrary_t library, const char* name) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t dptr;
    uint64_t bytes;
    uint64_t library;
    uint64_t name;
} hrr_args_hipLibraryGetManaged;

/* hipError_t hipLibraryEnumerateKernels(hipKernel_t* kernels, unsigned int numKernels, hipLibrary_t library) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t kernels;
    uint32_t numKernels;
    uint64_t library;
} hrr_args_hipLibraryEnumerateKernels;

/* hipError_t hipKernelGetLibrary(hipLibrary_t* library, hipKernel_t kernel) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t library;
    uint64_t kernel;
} hrr_args_hipKernelGetLibrary;

/* hipError_t hipKernelGetName(const char** name, hipKernel_t kernel) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t name;
    uint64_t kernel;
} hrr_args_hipKernelGetName;

/* hipError_t hipGetProcAddress_spt(const char* symbol, void** pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult* symbolStatus) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t symbol;
    uint64_t pfn;
    int32_t hipVersion;
    uint64_t flags;
    uint64_t symbolStatus;
} hrr_args_hipGetProcAddress_spt;

/* hipError_t hipExtDisableLogging() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipExtDisableLogging;

/* hipError_t hipExtEnableLogging() */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
} hrr_args_hipExtEnableLogging;

/* hipError_t hipExtSetLoggingParams(size_t log_level, size_t log_size, size_t log_mask) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t log_level;
    uint64_t log_size;
    uint64_t log_mask;
} hrr_args_hipExtSetLoggingParams;

/* hipError_t hipKernelGetAttribute(int* pi, hipFunction_attribute attrib, hipKernel_t kernel, hipDevice_t dev) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pi;
    uint64_t /* hipFunction_attribute */ attrib;
    uint64_t kernel;
    uint64_t dev;
} hrr_args_hipKernelGetAttribute;

/* hipError_t hipKernelSetAttribute(hipFunction_attribute attrib, int value, hipKernel_t kernel, hipDevice_t dev) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t /* hipFunction_attribute */ attrib;
    int32_t value;
    uint64_t kernel;
    uint64_t dev;
} hrr_args_hipKernelSetAttribute;

/* hipError_t hipKernelGetFunction(hipFunction_t* pFunc, hipKernel_t kernel) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pFunc;
    uint64_t kernel;
} hrr_args_hipKernelGetFunction;

/* hipError_t hipKernelGetParamInfo(hipKernel_t kernel, size_t paramIndex, size_t* paramOffset, size_t* paramSize) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t kernel;
    uint64_t paramIndex;
    uint64_t paramOffset;
    uint64_t paramSize;
} hrr_args_hipKernelGetParamInfo;

/* hipError_t hipMemSetMemPool(hipMemLocation* location, hipMemAllocationType type, hipMemPool_t pool) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t location;
    int32_t type;
    uint64_t pool;
} hrr_args_hipMemSetMemPool;

/* hipError_t hipMemGetMemPool(hipMemPool_t* pool, hipMemLocation* location, hipMemAllocationType type) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t pool;
    uint64_t location;
    int32_t type;
} hrr_args_hipMemGetMemPool;

/* hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements* memoryRequirements, hipMipmappedArray_t mipmap, hipDevice_t device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t memoryRequirements;
    uint64_t mipmap;
    uint64_t device;
} hrr_args_hipMipmappedArrayGetMemoryRequirements;

/* hipError_t hipGreenCtxCreate(hipExecutionCtx_t* ctx, hipDevResourceDesc_t desc, int device, unsigned int flags) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint64_t desc;
    int32_t device;
    uint32_t flags;
} hrr_args_hipGreenCtxCreate;

/* hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipExecutionCtxDestroy;

/* hipError_t hipExecutionCtxStreamCreate(hipStream_t* stream, hipExecutionCtx_t greenctx, unsigned int flags, int priority) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t stream;
    uint64_t greenctx;
    uint32_t flags;
    int32_t priority;
} hrr_args_hipExecutionCtxStreamCreate;

/* hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource* resource, hipDevResourceType type) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
    uint64_t resource;
    uint64_t /* hipDevResourceType */ type;
} hrr_args_hipDeviceGetDevResource;

/* hipError_t hipDevSmResourceSplitByCount(hipDevResource* result, unsigned int* nbGroups, const hipDevResource* input, hipDevResource* remainder, unsigned int flags, unsigned int minCount) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t result;
    uint64_t nbGroups;
    uint64_t input;
    uint64_t remainder;
    uint32_t flags;
    uint32_t minCount;
} hrr_args_hipDevSmResourceSplitByCount;

/* hipError_t hipDevSmResourceSplit(hipDevResource* result, unsigned int nbGroups, const hipDevResource* input, hipDevResource* remainder, unsigned int flags, hipDevSmResourceGroupParams* groupParams) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t result;
    uint32_t nbGroups;
    uint64_t input;
    uint64_t remainder;
    uint32_t flags;
    uint64_t groupParams;
} hrr_args_hipDevSmResourceSplit;

/* hipError_t hipDevResourceGenerateDesc(hipDevResourceDesc_t* phDesc, hipDevResource* resources, unsigned int nbResources) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t phDesc;
    uint64_t resources;
    uint32_t nbResources;
} hrr_args_hipDevResourceGenerateDesc;

/* hipError_t hipDeviceGetExecutionCtx(hipExecutionCtx_t* ctx, int device) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    int32_t device;
} hrr_args_hipDeviceGetExecutionCtx;

/* hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource* resource, hipDevResourceType type) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint64_t resource;
    uint64_t /* hipDevResourceType */ type;
} hrr_args_hipExecutionCtxGetDevResource;

/* hipError_t hipExecutionCtxGetDevice(int* device, hipExecutionCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t device;
    uint64_t ctx;
} hrr_args_hipExecutionCtxGetDevice;

/* hipError_t hipExecutionCtxGetId(hipExecutionCtx_t ctx, unsigned long long* ctxId) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint64_t ctxId;
} hrr_args_hipExecutionCtxGetId;

/* hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource* resource, hipDevResourceType type) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t hStream;
    uint64_t resource;
    uint64_t /* hipDevResourceType */ type;
} hrr_args_hipStreamGetDevResource;

/* hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint64_t event;
} hrr_args_hipExecutionCtxRecordEvent;

/* hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
} hrr_args_hipExecutionCtxSynchronize;

/* hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event) */
typedef struct {
    hrr_event_header hdr;
    int32_t ret;
    uint64_t ctx;
    uint64_t event;
} hrr_args_hipExecutionCtxWaitEvent;

/* ---- API id enumeration ---- */
typedef enum hrr_api_id {
    HRR_API_HIPPOPCALLCONFIGURATION = 0,
    HRR_API_HIPPUSHCALLCONFIGURATION = 1,
    HRR_API_HIPREGISTERFATBINARY = 2,
    HRR_API_HIPREGISTERFUNCTION = 3,
    HRR_API_HIPREGISTERMANAGEDVAR = 4,
    HRR_API_HIPREGISTERSURFACE = 5,
    HRR_API_HIPREGISTERTEXTURE = 6,
    HRR_API_HIPREGISTERVAR = 7,
    HRR_API_HIPUNREGISTERFATBINARY = 8,
    HRR_API_HIPAPINAME = 9,
    HRR_API_HIPARRAY3DCREATE = 10,
    HRR_API_HIPARRAY3DGETDESCRIPTOR = 11,
    HRR_API_HIPARRAYCREATE = 12,
    HRR_API_HIPARRAYDESTROY = 13,
    HRR_API_HIPARRAYGETDESCRIPTOR = 14,
    HRR_API_HIPARRAYGETINFO = 15,
    HRR_API_HIPBINDTEXTURE = 16,
    HRR_API_HIPBINDTEXTURE2D = 17,
    HRR_API_HIPBINDTEXTURETOARRAY = 18,
    HRR_API_HIPBINDTEXTURETOMIPMAPPEDARRAY = 19,
    HRR_API_HIPCHOOSEDEVICE = 20,
    HRR_API_HIPCHOOSEDEVICER0000 = 21,
    HRR_API_HIPCONFIGURECALL = 22,
    HRR_API_HIPCREATESURFACEOBJECT = 23,
    HRR_API_HIPCREATETEXTUREOBJECT = 24,
    HRR_API_HIPCTXCREATE = 25,
    HRR_API_HIPCTXDESTROY = 26,
    HRR_API_HIPCTXDISABLEPEERACCESS = 27,
    HRR_API_HIPCTXENABLEPEERACCESS = 28,
    HRR_API_HIPCTXGETAPIVERSION = 29,
    HRR_API_HIPCTXGETCACHECONFIG = 30,
    HRR_API_HIPCTXGETCURRENT = 31,
    HRR_API_HIPCTXGETDEVICE = 32,
    HRR_API_HIPCTXGETFLAGS = 33,
    HRR_API_HIPCTXGETSHAREDMEMCONFIG = 34,
    HRR_API_HIPCTXPOPCURRENT = 35,
    HRR_API_HIPCTXPUSHCURRENT = 36,
    HRR_API_HIPCTXSETCACHECONFIG = 37,
    HRR_API_HIPCTXSETCURRENT = 38,
    HRR_API_HIPCTXSETSHAREDMEMCONFIG = 39,
    HRR_API_HIPCTXSYNCHRONIZE = 40,
    HRR_API_HIPDESTROYEXTERNALMEMORY = 41,
    HRR_API_HIPDESTROYEXTERNALSEMAPHORE = 42,
    HRR_API_HIPDESTROYSURFACEOBJECT = 43,
    HRR_API_HIPDESTROYTEXTUREOBJECT = 44,
    HRR_API_HIPDEVICECANACCESSPEER = 45,
    HRR_API_HIPDEVICECOMPUTECAPABILITY = 46,
    HRR_API_HIPDEVICEDISABLEPEERACCESS = 47,
    HRR_API_HIPDEVICEENABLEPEERACCESS = 48,
    HRR_API_HIPDEVICEGET = 49,
    HRR_API_HIPDEVICEGETATTRIBUTE = 50,
    HRR_API_HIPDEVICEGETBYPCIBUSID = 51,
    HRR_API_HIPDEVICEGETCACHECONFIG = 52,
    HRR_API_HIPDEVICEGETDEFAULTMEMPOOL = 53,
    HRR_API_HIPDEVICEGETGRAPHMEMATTRIBUTE = 54,
    HRR_API_HIPDEVICEGETLIMIT = 55,
    HRR_API_HIPDEVICEGETMEMPOOL = 56,
    HRR_API_HIPDEVICEGETNAME = 57,
    HRR_API_HIPDEVICEGETP2PATTRIBUTE = 58,
    HRR_API_HIPDEVICEGETPCIBUSID = 59,
    HRR_API_HIPDEVICEGETSHAREDMEMCONFIG = 60,
    HRR_API_HIPDEVICEGETSTREAMPRIORITYRANGE = 61,
    HRR_API_HIPDEVICEGETUUID = 62,
    HRR_API_HIPDEVICEGRAPHMEMTRIM = 63,
    HRR_API_HIPDEVICEPRIMARYCTXGETSTATE = 64,
    HRR_API_HIPDEVICEPRIMARYCTXRELEASE = 65,
    HRR_API_HIPDEVICEPRIMARYCTXRESET = 66,
    HRR_API_HIPDEVICEPRIMARYCTXRETAIN = 67,
    HRR_API_HIPDEVICEPRIMARYCTXSETFLAGS = 68,
    HRR_API_HIPDEVICERESET = 69,
    HRR_API_HIPDEVICESETCACHECONFIG = 70,
    HRR_API_HIPDEVICESETGRAPHMEMATTRIBUTE = 71,
    HRR_API_HIPDEVICESETLIMIT = 72,
    HRR_API_HIPDEVICESETMEMPOOL = 73,
    HRR_API_HIPDEVICESETSHAREDMEMCONFIG = 74,
    HRR_API_HIPDEVICESYNCHRONIZE = 75,
    HRR_API_HIPDEVICETOTALMEM = 76,
    HRR_API_HIPDRIVERGETVERSION = 77,
    HRR_API_HIPDRVGETERRORNAME = 78,
    HRR_API_HIPDRVGETERRORSTRING = 79,
    HRR_API_HIPDRVGRAPHADDMEMCPYNODE = 80,
    HRR_API_HIPDRVMEMCPY2DUNALIGNED = 81,
    HRR_API_HIPDRVMEMCPY3D = 82,
    HRR_API_HIPDRVMEMCPY3DASYNC = 83,
    HRR_API_HIPDRVPOINTERGETATTRIBUTES = 84,
    HRR_API_HIPEVENTCREATE = 85,
    HRR_API_HIPEVENTCREATEWITHFLAGS = 86,
    HRR_API_HIPEVENTDESTROY = 87,
    HRR_API_HIPEVENTELAPSEDTIME = 88,
    HRR_API_HIPEVENTQUERY = 89,
    HRR_API_HIPEVENTRECORD = 90,
    HRR_API_HIPEVENTSYNCHRONIZE = 91,
    HRR_API_HIPEXTGETLINKTYPEANDHOPCOUNT = 92,
    HRR_API_HIPEXTLAUNCHKERNEL = 93,
    HRR_API_HIPEXTLAUNCHMULTIKERNELMULTIDEVICE = 94,
    HRR_API_HIPEXTMALLOCWITHFLAGS = 95,
    HRR_API_HIPEXTSTREAMCREATEWITHCUMASK = 96,
    HRR_API_HIPEXTSTREAMGETCUMASK = 97,
    HRR_API_HIPEXTERNALMEMORYGETMAPPEDBUFFER = 98,
    HRR_API_HIPFREE = 99,
    HRR_API_HIPFREEARRAY = 100,
    HRR_API_HIPFREEASYNC = 101,
    HRR_API_HIPFREEHOST = 102,
    HRR_API_HIPFREEMIPMAPPEDARRAY = 103,
    HRR_API_HIPFUNCGETATTRIBUTE = 104,
    HRR_API_HIPFUNCGETATTRIBUTES = 105,
    HRR_API_HIPFUNCSETATTRIBUTE = 106,
    HRR_API_HIPFUNCSETCACHECONFIG = 107,
    HRR_API_HIPFUNCSETSHAREDMEMCONFIG = 108,
    HRR_API_HIPGLGETDEVICES = 109,
    HRR_API_HIPGETCHANNELDESC = 110,
    HRR_API_HIPGETDEVICE = 111,
    HRR_API_HIPGETDEVICECOUNT = 112,
    HRR_API_HIPGETDEVICEFLAGS = 113,
    HRR_API_HIPGETDEVICEPROPERTIESR0600 = 114,
    HRR_API_HIPGETDEVICEPROPERTIESR0000 = 115,
    HRR_API_HIPGETERRORNAME = 116,
    HRR_API_HIPGETERRORSTRING = 117,
    HRR_API_HIPGETLASTERROR = 118,
    HRR_API_HIPGETMIPMAPPEDARRAYLEVEL = 119,
    HRR_API_HIPGETSYMBOLADDRESS = 120,
    HRR_API_HIPGETSYMBOLSIZE = 121,
    HRR_API_HIPGETTEXTUREALIGNMENTOFFSET = 122,
    HRR_API_HIPGETTEXTUREOBJECTRESOURCEDESC = 123,
    HRR_API_HIPGETTEXTUREOBJECTRESOURCEVIEWDESC = 124,
    HRR_API_HIPGETTEXTUREOBJECTTEXTUREDESC = 125,
    HRR_API_HIPGETTEXTUREREFERENCE = 126,
    HRR_API_HIPGRAPHADDCHILDGRAPHNODE = 127,
    HRR_API_HIPGRAPHADDDEPENDENCIES = 128,
    HRR_API_HIPGRAPHADDEMPTYNODE = 129,
    HRR_API_HIPGRAPHADDEVENTRECORDNODE = 130,
    HRR_API_HIPGRAPHADDEVENTWAITNODE = 131,
    HRR_API_HIPGRAPHADDHOSTNODE = 132,
    HRR_API_HIPGRAPHADDKERNELNODE = 133,
    HRR_API_HIPGRAPHADDMEMALLOCNODE = 134,
    HRR_API_HIPGRAPHADDMEMFREENODE = 135,
    HRR_API_HIPGRAPHADDMEMCPYNODE = 136,
    HRR_API_HIPGRAPHADDMEMCPYNODE1D = 137,
    HRR_API_HIPGRAPHADDMEMCPYNODEFROMSYMBOL = 138,
    HRR_API_HIPGRAPHADDMEMCPYNODETOSYMBOL = 139,
    HRR_API_HIPGRAPHADDMEMSETNODE = 140,
    HRR_API_HIPGRAPHCHILDGRAPHNODEGETGRAPH = 141,
    HRR_API_HIPGRAPHCLONE = 142,
    HRR_API_HIPGRAPHCREATE = 143,
    HRR_API_HIPGRAPHDEBUGDOTPRINT = 144,
    HRR_API_HIPGRAPHDESTROY = 145,
    HRR_API_HIPGRAPHDESTROYNODE = 146,
    HRR_API_HIPGRAPHEVENTRECORDNODEGETEVENT = 147,
    HRR_API_HIPGRAPHEVENTRECORDNODESETEVENT = 148,
    HRR_API_HIPGRAPHEVENTWAITNODEGETEVENT = 149,
    HRR_API_HIPGRAPHEVENTWAITNODESETEVENT = 150,
    HRR_API_HIPGRAPHEXECCHILDGRAPHNODESETPARAMS = 151,
    HRR_API_HIPGRAPHEXECDESTROY = 152,
    HRR_API_HIPGRAPHEXECEVENTRECORDNODESETEVENT = 153,
    HRR_API_HIPGRAPHEXECEVENTWAITNODESETEVENT = 154,
    HRR_API_HIPGRAPHEXECHOSTNODESETPARAMS = 155,
    HRR_API_HIPGRAPHEXECKERNELNODESETPARAMS = 156,
    HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMS = 157,
    HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMS1D = 158,
    HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMSFROMSYMBOL = 159,
    HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMSTOSYMBOL = 160,
    HRR_API_HIPGRAPHEXECMEMSETNODESETPARAMS = 161,
    HRR_API_HIPGRAPHEXECUPDATE = 162,
    HRR_API_HIPGRAPHGETEDGES = 163,
    HRR_API_HIPGRAPHGETNODES = 164,
    HRR_API_HIPGRAPHGETROOTNODES = 165,
    HRR_API_HIPGRAPHHOSTNODEGETPARAMS = 166,
    HRR_API_HIPGRAPHHOSTNODESETPARAMS = 167,
    HRR_API_HIPGRAPHINSTANTIATE = 168,
    HRR_API_HIPGRAPHINSTANTIATEWITHFLAGS = 169,
    HRR_API_HIPGRAPHKERNELNODECOPYATTRIBUTES = 170,
    HRR_API_HIPGRAPHKERNELNODEGETATTRIBUTE = 171,
    HRR_API_HIPGRAPHKERNELNODEGETPARAMS = 172,
    HRR_API_HIPGRAPHKERNELNODESETATTRIBUTE = 173,
    HRR_API_HIPGRAPHKERNELNODESETPARAMS = 174,
    HRR_API_HIPGRAPHLAUNCH = 175,
    HRR_API_HIPGRAPHMEMALLOCNODEGETPARAMS = 176,
    HRR_API_HIPGRAPHMEMFREENODEGETPARAMS = 177,
    HRR_API_HIPGRAPHMEMCPYNODEGETPARAMS = 178,
    HRR_API_HIPGRAPHMEMCPYNODESETPARAMS = 179,
    HRR_API_HIPGRAPHMEMCPYNODESETPARAMS1D = 180,
    HRR_API_HIPGRAPHMEMCPYNODESETPARAMSFROMSYMBOL = 181,
    HRR_API_HIPGRAPHMEMCPYNODESETPARAMSTOSYMBOL = 182,
    HRR_API_HIPGRAPHMEMSETNODEGETPARAMS = 183,
    HRR_API_HIPGRAPHMEMSETNODESETPARAMS = 184,
    HRR_API_HIPGRAPHNODEFINDINCLONE = 185,
    HRR_API_HIPGRAPHNODEGETDEPENDENCIES = 186,
    HRR_API_HIPGRAPHNODEGETDEPENDENTNODES = 187,
    HRR_API_HIPGRAPHNODEGETENABLED = 188,
    HRR_API_HIPGRAPHNODEGETTYPE = 189,
    HRR_API_HIPGRAPHNODESETENABLED = 190,
    HRR_API_HIPGRAPHRELEASEUSEROBJECT = 191,
    HRR_API_HIPGRAPHREMOVEDEPENDENCIES = 192,
    HRR_API_HIPGRAPHRETAINUSEROBJECT = 193,
    HRR_API_HIPGRAPHUPLOAD = 194,
    HRR_API_HIPGRAPHICSGLREGISTERBUFFER = 195,
    HRR_API_HIPGRAPHICSGLREGISTERIMAGE = 196,
    HRR_API_HIPGRAPHICSMAPRESOURCES = 197,
    HRR_API_HIPGRAPHICSRESOURCEGETMAPPEDPOINTER = 198,
    HRR_API_HIPGRAPHICSSUBRESOURCEGETMAPPEDARRAY = 199,
    HRR_API_HIPGRAPHICSUNMAPRESOURCES = 200,
    HRR_API_HIPGRAPHICSUNREGISTERRESOURCE = 201,
    HRR_API_HIPHOSTALLOC = 202,
    HRR_API_HIPHOSTFREE = 203,
    HRR_API_HIPHOSTGETDEVICEPOINTER = 204,
    HRR_API_HIPHOSTGETFLAGS = 205,
    HRR_API_HIPHOSTMALLOC = 206,
    HRR_API_HIPHOSTREGISTER = 207,
    HRR_API_HIPHOSTUNREGISTER = 208,
    HRR_API_HIPIMPORTEXTERNALMEMORY = 209,
    HRR_API_HIPIMPORTEXTERNALSEMAPHORE = 210,
    HRR_API_HIPINIT = 211,
    HRR_API_HIPIPCCLOSEMEMHANDLE = 212,
    HRR_API_HIPIPCGETEVENTHANDLE = 213,
    HRR_API_HIPIPCGETMEMHANDLE = 214,
    HRR_API_HIPIPCOPENEVENTHANDLE = 215,
    HRR_API_HIPIPCOPENMEMHANDLE = 216,
    HRR_API_HIPKERNELNAMEREF = 217,
    HRR_API_HIPKERNELNAMEREFBYPTR = 218,
    HRR_API_HIPLAUNCHBYPTR = 219,
    HRR_API_HIPLAUNCHCOOPERATIVEKERNEL = 220,
    HRR_API_HIPLAUNCHCOOPERATIVEKERNELMULTIDEVICE = 221,
    HRR_API_HIPLAUNCHHOSTFUNC = 222,
    HRR_API_HIPLAUNCHKERNEL = 223,
    HRR_API_HIPMALLOC = 224,
    HRR_API_HIPMALLOC3D = 225,
    HRR_API_HIPMALLOC3DARRAY = 226,
    HRR_API_HIPMALLOCARRAY = 227,
    HRR_API_HIPMALLOCASYNC = 228,
    HRR_API_HIPMALLOCFROMPOOLASYNC = 229,
    HRR_API_HIPMALLOCHOST = 230,
    HRR_API_HIPMALLOCMANAGED = 231,
    HRR_API_HIPMALLOCMIPMAPPEDARRAY = 232,
    HRR_API_HIPMALLOCPITCH = 233,
    HRR_API_HIPMEMADDRESSFREE = 234,
    HRR_API_HIPMEMADDRESSRESERVE = 235,
    HRR_API_HIPMEMADVISE = 236,
    HRR_API_HIPMEMADVISE_V2 = 237,
    HRR_API_HIPMEMALLOCHOST = 238,
    HRR_API_HIPMEMALLOCPITCH = 239,
    HRR_API_HIPMEMCREATE = 240,
    HRR_API_HIPMEMEXPORTTOSHAREABLEHANDLE = 241,
    HRR_API_HIPMEMGETACCESS = 242,
    HRR_API_HIPMEMGETADDRESSRANGE = 243,
    HRR_API_HIPMEMGETALLOCATIONGRANULARITY = 244,
    HRR_API_HIPMEMGETALLOCATIONPROPERTIESFROMHANDLE = 245,
    HRR_API_HIPMEMGETINFO = 246,
    HRR_API_HIPMEMIMPORTFROMSHAREABLEHANDLE = 247,
    HRR_API_HIPMEMMAP = 248,
    HRR_API_HIPMEMMAPARRAYASYNC = 249,
    HRR_API_HIPMEMPOOLCREATE = 250,
    HRR_API_HIPMEMPOOLDESTROY = 251,
    HRR_API_HIPMEMPOOLEXPORTPOINTER = 252,
    HRR_API_HIPMEMPOOLEXPORTTOSHAREABLEHANDLE = 253,
    HRR_API_HIPMEMPOOLGETACCESS = 254,
    HRR_API_HIPMEMPOOLGETATTRIBUTE = 255,
    HRR_API_HIPMEMPOOLIMPORTFROMSHAREABLEHANDLE = 256,
    HRR_API_HIPMEMPOOLIMPORTPOINTER = 257,
    HRR_API_HIPMEMPOOLSETACCESS = 258,
    HRR_API_HIPMEMPOOLSETATTRIBUTE = 259,
    HRR_API_HIPMEMPOOLTRIMTO = 260,
    HRR_API_HIPMEMPREFETCHASYNC = 261,
    HRR_API_HIPMEMPREFETCHASYNC_V2 = 262,
    HRR_API_HIPMEMPREFETCHBATCHASYNC = 263,
    HRR_API_HIPMEMDISCARDBATCHASYNC = 264,
    HRR_API_HIPDRVMEMDISCARDBATCHASYNC = 265,
    HRR_API_HIPMEMDISCARDANDPREFETCHBATCHASYNC = 266,
    HRR_API_HIPDRVMEMDISCARDANDPREFETCHBATCHASYNC = 267,
    HRR_API_HIPMEMPTRGETINFO = 268,
    HRR_API_HIPMEMRANGEGETATTRIBUTE = 269,
    HRR_API_HIPMEMRANGEGETATTRIBUTES = 270,
    HRR_API_HIPMEMRELEASE = 271,
    HRR_API_HIPMEMRETAINALLOCATIONHANDLE = 272,
    HRR_API_HIPMEMSETACCESS = 273,
    HRR_API_HIPMEMUNMAP = 274,
    HRR_API_HIPMEMCPY = 275,
    HRR_API_HIPMEMCPY2D = 276,
    HRR_API_HIPMEMCPY2DASYNC = 277,
    HRR_API_HIPMEMCPY2DFROMARRAY = 278,
    HRR_API_HIPMEMCPY2DFROMARRAYASYNC = 279,
    HRR_API_HIPMEMCPY2DTOARRAY = 280,
    HRR_API_HIPMEMCPY2DTOARRAYASYNC = 281,
    HRR_API_HIPMEMCPY3D = 282,
    HRR_API_HIPMEMCPY3DASYNC = 283,
    HRR_API_HIPMEMCPYASYNC = 284,
    HRR_API_HIPMEMCPYATOH = 285,
    HRR_API_HIPMEMCPYDTOD = 286,
    HRR_API_HIPMEMCPYDTODASYNC = 287,
    HRR_API_HIPMEMCPYDTOH = 288,
    HRR_API_HIPMEMCPYDTOHASYNC = 289,
    HRR_API_HIPMEMCPYFROMARRAY = 290,
    HRR_API_HIPMEMCPYFROMSYMBOL = 291,
    HRR_API_HIPMEMCPYFROMSYMBOLASYNC = 292,
    HRR_API_HIPMEMCPYHTOA = 293,
    HRR_API_HIPMEMCPYHTOD = 294,
    HRR_API_HIPMEMCPYHTODASYNC = 295,
    HRR_API_HIPMEMCPYPARAM2D = 296,
    HRR_API_HIPMEMCPYPARAM2DASYNC = 297,
    HRR_API_HIPMEMCPYPEER = 298,
    HRR_API_HIPMEMCPYPEERASYNC = 299,
    HRR_API_HIPMEMCPYTOARRAY = 300,
    HRR_API_HIPMEMCPYTOSYMBOL = 301,
    HRR_API_HIPMEMCPYTOSYMBOLASYNC = 302,
    HRR_API_HIPMEMCPYWITHSTREAM = 303,
    HRR_API_HIPMEMSET = 304,
    HRR_API_HIPMEMSET2D = 305,
    HRR_API_HIPMEMSET2DASYNC = 306,
    HRR_API_HIPMEMSET3D = 307,
    HRR_API_HIPMEMSET3DASYNC = 308,
    HRR_API_HIPMEMSETASYNC = 309,
    HRR_API_HIPMEMSETD16 = 310,
    HRR_API_HIPMEMSETD16ASYNC = 311,
    HRR_API_HIPMEMSETD32 = 312,
    HRR_API_HIPMEMSETD32ASYNC = 313,
    HRR_API_HIPMEMSETD8 = 314,
    HRR_API_HIPMEMSETD8ASYNC = 315,
    HRR_API_HIPMIPMAPPEDARRAYCREATE = 316,
    HRR_API_HIPMIPMAPPEDARRAYDESTROY = 317,
    HRR_API_HIPMIPMAPPEDARRAYGETLEVEL = 318,
    HRR_API_HIPMODULEGETFUNCTION = 319,
    HRR_API_HIPMODULEGETFUNCTIONCOUNT = 320,
    HRR_API_HIPMODULEGETGLOBAL = 321,
    HRR_API_HIPMODULEGETTEXREF = 322,
    HRR_API_HIPMODULELAUNCHCOOPERATIVEKERNEL = 323,
    HRR_API_HIPMODULELAUNCHCOOPERATIVEKERNELMULTIDEVICE = 324,
    HRR_API_HIPMODULELAUNCHKERNEL = 325,
    HRR_API_HIPMODULELOAD = 326,
    HRR_API_HIPMODULELOADDATA = 327,
    HRR_API_HIPMODULELOADDATAEX = 328,
    HRR_API_HIPLINKADDDATA = 329,
    HRR_API_HIPLINKADDFILE = 330,
    HRR_API_HIPLINKCOMPLETE = 331,
    HRR_API_HIPLINKCREATE = 332,
    HRR_API_HIPLINKDESTROY = 333,
    HRR_API_HIPMODULEOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSOR = 334,
    HRR_API_HIPMODULEOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSORWITHFLAGS = 335,
    HRR_API_HIPMODULEOCCUPANCYMAXPOTENTIALBLOCKSIZE = 336,
    HRR_API_HIPMODULEOCCUPANCYMAXPOTENTIALBLOCKSIZEWITHFLAGS = 337,
    HRR_API_HIPMODULEUNLOAD = 338,
    HRR_API_HIPOCCUPANCYAVAILABLEDYNAMICSMEMPERBLOCK = 339,
    HRR_API_HIPOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSOR = 340,
    HRR_API_HIPOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSORWITHFLAGS = 341,
    HRR_API_HIPOCCUPANCYMAXPOTENTIALBLOCKSIZE = 342,
    HRR_API_HIPOCCUPANCYMAXACTIVECLUSTERS = 343,
    HRR_API_HIPOCCUPANCYMAXPOTENTIALCLUSTERSIZE = 344,
    HRR_API_HIPPEEKATLASTERROR = 345,
    HRR_API_HIPPOINTERGETATTRIBUTE = 346,
    HRR_API_HIPPOINTERGETATTRIBUTES = 347,
    HRR_API_HIPPOINTERSETATTRIBUTE = 348,
    HRR_API_HIPPROFILERSTART = 349,
    HRR_API_HIPPROFILERSTOP = 350,
    HRR_API_HIPRUNTIMEGETVERSION = 351,
    HRR_API_HIPSETDEVICE = 352,
    HRR_API_HIPSETDEVICEFLAGS = 353,
    HRR_API_HIPSETUPARGUMENT = 354,
    HRR_API_HIPSIGNALEXTERNALSEMAPHORESASYNC = 355,
    HRR_API_HIPSTREAMADDCALLBACK = 356,
    HRR_API_HIPSTREAMATTACHMEMASYNC = 357,
    HRR_API_HIPSTREAMBEGINCAPTURE = 358,
    HRR_API_HIPSTREAMCOPYATTRIBUTES = 359,
    HRR_API_HIPSTREAMCREATE = 360,
    HRR_API_HIPSTREAMCREATEWITHFLAGS = 361,
    HRR_API_HIPSTREAMCREATEWITHPRIORITY = 362,
    HRR_API_HIPSTREAMDESTROY = 363,
    HRR_API_HIPSTREAMENDCAPTURE = 364,
    HRR_API_HIPSTREAMGETCAPTUREINFO = 365,
    HRR_API_HIPSTREAMGETCAPTUREINFO_V2 = 366,
    HRR_API_HIPSTREAMGETDEVICE = 367,
    HRR_API_HIPSTREAMGETFLAGS = 368,
    HRR_API_HIPSTREAMGETID = 369,
    HRR_API_HIPSTREAMGETPRIORITY = 370,
    HRR_API_HIPSTREAMISCAPTURING = 371,
    HRR_API_HIPSTREAMQUERY = 372,
    HRR_API_HIPSTREAMSYNCHRONIZE = 373,
    HRR_API_HIPSTREAMUPDATECAPTUREDEPENDENCIES = 374,
    HRR_API_HIPSTREAMWAITEVENT = 375,
    HRR_API_HIPSTREAMWAITVALUE32 = 376,
    HRR_API_HIPSTREAMWAITVALUE64 = 377,
    HRR_API_HIPSTREAMWRITEVALUE32 = 378,
    HRR_API_HIPSTREAMWRITEVALUE64 = 379,
    HRR_API_HIPSTREAMBATCHMEMOP = 380,
    HRR_API_HIPTEXOBJECTCREATE = 381,
    HRR_API_HIPTEXOBJECTDESTROY = 382,
    HRR_API_HIPTEXOBJECTGETRESOURCEDESC = 383,
    HRR_API_HIPTEXOBJECTGETRESOURCEVIEWDESC = 384,
    HRR_API_HIPTEXOBJECTGETTEXTUREDESC = 385,
    HRR_API_HIPTEXREFGETADDRESS = 386,
    HRR_API_HIPTEXREFGETADDRESSMODE = 387,
    HRR_API_HIPTEXREFGETFILTERMODE = 388,
    HRR_API_HIPTEXREFGETFLAGS = 389,
    HRR_API_HIPTEXREFGETFORMAT = 390,
    HRR_API_HIPTEXREFGETMAXANISOTROPY = 391,
    HRR_API_HIPTEXREFGETMIPMAPPEDARRAY = 392,
    HRR_API_HIPTEXREFGETMIPMAPFILTERMODE = 393,
    HRR_API_HIPTEXREFGETMIPMAPLEVELBIAS = 394,
    HRR_API_HIPTEXREFGETMIPMAPLEVELCLAMP = 395,
    HRR_API_HIPTEXREFSETADDRESS = 396,
    HRR_API_HIPTEXREFSETADDRESS2D = 397,
    HRR_API_HIPTEXREFSETADDRESSMODE = 398,
    HRR_API_HIPTEXREFSETARRAY = 399,
    HRR_API_HIPTEXREFSETBORDERCOLOR = 400,
    HRR_API_HIPTEXREFSETFILTERMODE = 401,
    HRR_API_HIPTEXREFSETFLAGS = 402,
    HRR_API_HIPTEXREFSETFORMAT = 403,
    HRR_API_HIPTEXREFSETMAXANISOTROPY = 404,
    HRR_API_HIPTEXREFSETMIPMAPFILTERMODE = 405,
    HRR_API_HIPTEXREFSETMIPMAPLEVELBIAS = 406,
    HRR_API_HIPTEXREFSETMIPMAPLEVELCLAMP = 407,
    HRR_API_HIPTEXREFSETMIPMAPPEDARRAY = 408,
    HRR_API_HIPTHREADEXCHANGESTREAMCAPTUREMODE = 409,
    HRR_API_HIPUNBINDTEXTURE = 410,
    HRR_API_HIPUSEROBJECTCREATE = 411,
    HRR_API_HIPUSEROBJECTRELEASE = 412,
    HRR_API_HIPUSEROBJECTRETAIN = 413,
    HRR_API_HIPWAITEXTERNALSEMAPHORESASYNC = 414,
    HRR_API_HIPMEMCPY_SPT = 415,
    HRR_API_HIPMEMCPYTOSYMBOL_SPT = 416,
    HRR_API_HIPMEMCPYFROMSYMBOL_SPT = 417,
    HRR_API_HIPMEMCPY2D_SPT = 418,
    HRR_API_HIPMEMCPY2DFROMARRAY_SPT = 419,
    HRR_API_HIPMEMCPY3D_SPT = 420,
    HRR_API_HIPMEMSET_SPT = 421,
    HRR_API_HIPMEMSETASYNC_SPT = 422,
    HRR_API_HIPMEMSET2D_SPT = 423,
    HRR_API_HIPMEMSET2DASYNC_SPT = 424,
    HRR_API_HIPMEMSET3DASYNC_SPT = 425,
    HRR_API_HIPMEMSET3D_SPT = 426,
    HRR_API_HIPMEMCPYASYNC_SPT = 427,
    HRR_API_HIPMEMCPY3DASYNC_SPT = 428,
    HRR_API_HIPMEMCPY2DASYNC_SPT = 429,
    HRR_API_HIPMEMCPYFROMSYMBOLASYNC_SPT = 430,
    HRR_API_HIPMEMCPYTOSYMBOLASYNC_SPT = 431,
    HRR_API_HIPMEMCPYFROMARRAY_SPT = 432,
    HRR_API_HIPMEMCPY2DTOARRAY_SPT = 433,
    HRR_API_HIPMEMCPY2DFROMARRAYASYNC_SPT = 434,
    HRR_API_HIPMEMCPY2DTOARRAYASYNC_SPT = 435,
    HRR_API_HIPSTREAMQUERY_SPT = 436,
    HRR_API_HIPSTREAMSYNCHRONIZE_SPT = 437,
    HRR_API_HIPSTREAMGETPRIORITY_SPT = 438,
    HRR_API_HIPSTREAMWAITEVENT_SPT = 439,
    HRR_API_HIPSTREAMGETFLAGS_SPT = 440,
    HRR_API_HIPSTREAMADDCALLBACK_SPT = 441,
    HRR_API_HIPEVENTRECORD_SPT = 442,
    HRR_API_HIPLAUNCHCOOPERATIVEKERNEL_SPT = 443,
    HRR_API_HIPLAUNCHKERNEL_SPT = 444,
    HRR_API_HIPGRAPHLAUNCH_SPT = 445,
    HRR_API_HIPSTREAMBEGINCAPTURE_SPT = 446,
    HRR_API_HIPSTREAMENDCAPTURE_SPT = 447,
    HRR_API_HIPSTREAMISCAPTURING_SPT = 448,
    HRR_API_HIPSTREAMGETCAPTUREINFO_SPT = 449,
    HRR_API_HIPSTREAMGETCAPTUREINFO_V2_SPT = 450,
    HRR_API_HIPLAUNCHHOSTFUNC_SPT = 451,
    HRR_API_HIPCREATECHANNELDESC = 452,
    HRR_API_HIPEXTMODULELAUNCHKERNEL = 453,
    HRR_API_HIPHCCMODULELAUNCHKERNEL = 454,
    HRR_API_HIPGETSTREAMDEVICEID = 455,
    HRR_API_HIPDRVGRAPHADDMEMSETNODE = 456,
    HRR_API_HIPGRAPHADDEXTERNALSEMAPHORESWAITNODE = 457,
    HRR_API_HIPGRAPHADDEXTERNALSEMAPHORESSIGNALNODE = 458,
    HRR_API_HIPGRAPHEXTERNALSEMAPHORESSIGNALNODESETPARAMS = 459,
    HRR_API_HIPGRAPHEXTERNALSEMAPHORESWAITNODESETPARAMS = 460,
    HRR_API_HIPGRAPHEXTERNALSEMAPHORESSIGNALNODEGETPARAMS = 461,
    HRR_API_HIPGRAPHEXTERNALSEMAPHORESWAITNODEGETPARAMS = 462,
    HRR_API_HIPGRAPHEXECEXTERNALSEMAPHORESSIGNALNODESETPARAMS = 463,
    HRR_API_HIPGRAPHEXECEXTERNALSEMAPHORESWAITNODESETPARAMS = 464,
    HRR_API_HIPGRAPHADDNODE = 465,
    HRR_API_HIPGRAPHINSTANTIATEWITHPARAMS = 466,
    HRR_API_HIPEXTGETLASTERROR = 467,
    HRR_API_HIPTEXREFGETBORDERCOLOR = 468,
    HRR_API_HIPTEXREFGETARRAY = 469,
    HRR_API_HIPGETPROCADDRESS = 470,
    HRR_API_HIPSTREAMBEGINCAPTURETOGRAPH = 471,
    HRR_API_HIPGETFUNCBYSYMBOL = 472,
    HRR_API_HIPDRVGRAPHADDMEMFREENODE = 473,
    HRR_API_HIPDRVGRAPHEXECMEMCPYNODESETPARAMS = 474,
    HRR_API_HIPDRVGRAPHEXECMEMSETNODESETPARAMS = 475,
    HRR_API_HIPSETVALIDDEVICES = 476,
    HRR_API_HIPMEMCPYATOD = 477,
    HRR_API_HIPMEMCPYDTOA = 478,
    HRR_API_HIPMEMCPYATOA = 479,
    HRR_API_HIPMEMCPYATOHASYNC = 480,
    HRR_API_HIPMEMCPYHTOAASYNC = 481,
    HRR_API_HIPMEMCPY2DARRAYTOARRAY = 482,
    HRR_API_HIPGRAPHEXECGETFLAGS = 483,
    HRR_API_HIPGRAPHNODESETPARAMS = 484,
    HRR_API_HIPGRAPHEXECNODESETPARAMS = 485,
    HRR_API_HIPEXTERNALMEMORYGETMAPPEDMIPMAPPEDARRAY = 486,
    HRR_API_HIPDRVGRAPHMEMCPYNODEGETPARAMS = 487,
    HRR_API_HIPDRVGRAPHMEMCPYNODESETPARAMS = 488,
    HRR_API_HIPEXTHOSTALLOC = 489,
    HRR_API_HIPDEVICEGETTEXTURE1DLINEARMAXWIDTH = 490,
    HRR_API_HIPGRAPHADDBATCHMEMOPNODE = 491,
    HRR_API_HIPGRAPHBATCHMEMOPNODEGETPARAMS = 492,
    HRR_API_HIPGRAPHBATCHMEMOPNODESETPARAMS = 493,
    HRR_API_HIPGRAPHEXECBATCHMEMOPNODESETPARAMS = 494,
    HRR_API_HIPEVENTRECORDWITHFLAGS = 495,
    HRR_API_HIPLAUNCHKERNELEXC = 496,
    HRR_API_HIPDRVLAUNCHKERNELEX = 497,
    HRR_API_HIPMEMGETHANDLEFORADDRESSRANGE = 498,
    HRR_API_HIPMEMSETD2D8 = 499,
    HRR_API_HIPMEMSETD2D8ASYNC = 500,
    HRR_API_HIPMEMSETD2D16 = 501,
    HRR_API_HIPMEMSETD2D16ASYNC = 502,
    HRR_API_HIPMEMSETD2D32 = 503,
    HRR_API_HIPMEMSETD2D32ASYNC = 504,
    HRR_API_HIPSTREAMSETATTRIBUTE = 505,
    HRR_API_HIPSTREAMGETATTRIBUTE = 506,
    HRR_API_HIPMODULELOADFATBINARY = 507,
    HRR_API_HIPMEMCPYBATCHASYNC = 508,
    HRR_API_HIPMEMCPY3DBATCHASYNC = 509,
    HRR_API_HIPMEMCPY3DPEER = 510,
    HRR_API_HIPMEMCPY3DPEERASYNC = 511,
    HRR_API_HIPGETDRIVERENTRYPOINT = 512,
    HRR_API_HIPGETDRIVERENTRYPOINT_SPT = 513,
    HRR_API_HIPLIBRARYLOADDATA = 514,
    HRR_API_HIPLIBRARYLOADFROMFILE = 515,
    HRR_API_HIPLIBRARYUNLOAD = 516,
    HRR_API_HIPLIBRARYGETKERNEL = 517,
    HRR_API_HIPLIBRARYGETKERNELCOUNT = 518,
    HRR_API_HIPLIBRARYGETGLOBAL = 519,
    HRR_API_HIPLIBRARYGETMANAGED = 520,
    HRR_API_HIPLIBRARYENUMERATEKERNELS = 521,
    HRR_API_HIPKERNELGETLIBRARY = 522,
    HRR_API_HIPKERNELGETNAME = 523,
    HRR_API_HIPGETPROCADDRESS_SPT = 524,
    HRR_API_HIPEXTDISABLELOGGING = 525,
    HRR_API_HIPEXTENABLELOGGING = 526,
    HRR_API_HIPEXTSETLOGGINGPARAMS = 527,
    HRR_API_HIPKERNELGETATTRIBUTE = 528,
    HRR_API_HIPKERNELSETATTRIBUTE = 529,
    HRR_API_HIPKERNELGETFUNCTION = 530,
    HRR_API_HIPKERNELGETPARAMINFO = 531,
    HRR_API_HIPMEMSETMEMPOOL = 532,
    HRR_API_HIPMEMGETMEMPOOL = 533,
    HRR_API_HIPMIPMAPPEDARRAYGETMEMORYREQUIREMENTS = 534,
    HRR_API_HIPGREENCTXCREATE = 535,
    HRR_API_HIPEXECUTIONCTXDESTROY = 536,
    HRR_API_HIPEXECUTIONCTXSTREAMCREATE = 537,
    HRR_API_HIPDEVICEGETDEVRESOURCE = 538,
    HRR_API_HIPDEVSMRESOURCESPLITBYCOUNT = 539,
    HRR_API_HIPDEVSMRESOURCESPLIT = 540,
    HRR_API_HIPDEVRESOURCEGENERATEDESC = 541,
    HRR_API_HIPDEVICEGETEXECUTIONCTX = 542,
    HRR_API_HIPEXECUTIONCTXGETDEVRESOURCE = 543,
    HRR_API_HIPEXECUTIONCTXGETDEVICE = 544,
    HRR_API_HIPEXECUTIONCTXGETID = 545,
    HRR_API_HIPSTREAMGETDEVRESOURCE = 546,
    HRR_API_HIPEXECUTIONCTXRECORDEVENT = 547,
    HRR_API_HIPEXECUTIONCTXSYNCHRONIZE = 548,
    HRR_API_HIPEXECUTIONCTXWAITEVENT = 549,
    HRR_API_COUNT = 550
} hrr_api_id_t;

/* Array of API names indexed by hrr_api_id_t */
#ifdef HRR_API_ARGS_IMPLEMENTATION
const char* const hrr_api_names[HRR_API_COUNT] = {
    "__hipPopCallConfiguration",
    "__hipPushCallConfiguration",
    "__hipRegisterFatBinary",
    "__hipRegisterFunction",
    "__hipRegisterManagedVar",
    "__hipRegisterSurface",
    "__hipRegisterTexture",
    "__hipRegisterVar",
    "__hipUnregisterFatBinary",
    "hipApiName",
    "hipArray3DCreate",
    "hipArray3DGetDescriptor",
    "hipArrayCreate",
    "hipArrayDestroy",
    "hipArrayGetDescriptor",
    "hipArrayGetInfo",
    "hipBindTexture",
    "hipBindTexture2D",
    "hipBindTextureToArray",
    "hipBindTextureToMipmappedArray",
    "hipChooseDevice",
    "hipChooseDeviceR0000",
    "hipConfigureCall",
    "hipCreateSurfaceObject",
    "hipCreateTextureObject",
    "hipCtxCreate",
    "hipCtxDestroy",
    "hipCtxDisablePeerAccess",
    "hipCtxEnablePeerAccess",
    "hipCtxGetApiVersion",
    "hipCtxGetCacheConfig",
    "hipCtxGetCurrent",
    "hipCtxGetDevice",
    "hipCtxGetFlags",
    "hipCtxGetSharedMemConfig",
    "hipCtxPopCurrent",
    "hipCtxPushCurrent",
    "hipCtxSetCacheConfig",
    "hipCtxSetCurrent",
    "hipCtxSetSharedMemConfig",
    "hipCtxSynchronize",
    "hipDestroyExternalMemory",
    "hipDestroyExternalSemaphore",
    "hipDestroySurfaceObject",
    "hipDestroyTextureObject",
    "hipDeviceCanAccessPeer",
    "hipDeviceComputeCapability",
    "hipDeviceDisablePeerAccess",
    "hipDeviceEnablePeerAccess",
    "hipDeviceGet",
    "hipDeviceGetAttribute",
    "hipDeviceGetByPCIBusId",
    "hipDeviceGetCacheConfig",
    "hipDeviceGetDefaultMemPool",
    "hipDeviceGetGraphMemAttribute",
    "hipDeviceGetLimit",
    "hipDeviceGetMemPool",
    "hipDeviceGetName",
    "hipDeviceGetP2PAttribute",
    "hipDeviceGetPCIBusId",
    "hipDeviceGetSharedMemConfig",
    "hipDeviceGetStreamPriorityRange",
    "hipDeviceGetUuid",
    "hipDeviceGraphMemTrim",
    "hipDevicePrimaryCtxGetState",
    "hipDevicePrimaryCtxRelease",
    "hipDevicePrimaryCtxReset",
    "hipDevicePrimaryCtxRetain",
    "hipDevicePrimaryCtxSetFlags",
    "hipDeviceReset",
    "hipDeviceSetCacheConfig",
    "hipDeviceSetGraphMemAttribute",
    "hipDeviceSetLimit",
    "hipDeviceSetMemPool",
    "hipDeviceSetSharedMemConfig",
    "hipDeviceSynchronize",
    "hipDeviceTotalMem",
    "hipDriverGetVersion",
    "hipDrvGetErrorName",
    "hipDrvGetErrorString",
    "hipDrvGraphAddMemcpyNode",
    "hipDrvMemcpy2DUnaligned",
    "hipDrvMemcpy3D",
    "hipDrvMemcpy3DAsync",
    "hipDrvPointerGetAttributes",
    "hipEventCreate",
    "hipEventCreateWithFlags",
    "hipEventDestroy",
    "hipEventElapsedTime",
    "hipEventQuery",
    "hipEventRecord",
    "hipEventSynchronize",
    "hipExtGetLinkTypeAndHopCount",
    "hipExtLaunchKernel",
    "hipExtLaunchMultiKernelMultiDevice",
    "hipExtMallocWithFlags",
    "hipExtStreamCreateWithCUMask",
    "hipExtStreamGetCUMask",
    "hipExternalMemoryGetMappedBuffer",
    "hipFree",
    "hipFreeArray",
    "hipFreeAsync",
    "hipFreeHost",
    "hipFreeMipmappedArray",
    "hipFuncGetAttribute",
    "hipFuncGetAttributes",
    "hipFuncSetAttribute",
    "hipFuncSetCacheConfig",
    "hipFuncSetSharedMemConfig",
    "hipGLGetDevices",
    "hipGetChannelDesc",
    "hipGetDevice",
    "hipGetDeviceCount",
    "hipGetDeviceFlags",
    "hipGetDevicePropertiesR0600",
    "hipGetDevicePropertiesR0000",
    "hipGetErrorName",
    "hipGetErrorString",
    "hipGetLastError",
    "hipGetMipmappedArrayLevel",
    "hipGetSymbolAddress",
    "hipGetSymbolSize",
    "hipGetTextureAlignmentOffset",
    "hipGetTextureObjectResourceDesc",
    "hipGetTextureObjectResourceViewDesc",
    "hipGetTextureObjectTextureDesc",
    "hipGetTextureReference",
    "hipGraphAddChildGraphNode",
    "hipGraphAddDependencies",
    "hipGraphAddEmptyNode",
    "hipGraphAddEventRecordNode",
    "hipGraphAddEventWaitNode",
    "hipGraphAddHostNode",
    "hipGraphAddKernelNode",
    "hipGraphAddMemAllocNode",
    "hipGraphAddMemFreeNode",
    "hipGraphAddMemcpyNode",
    "hipGraphAddMemcpyNode1D",
    "hipGraphAddMemcpyNodeFromSymbol",
    "hipGraphAddMemcpyNodeToSymbol",
    "hipGraphAddMemsetNode",
    "hipGraphChildGraphNodeGetGraph",
    "hipGraphClone",
    "hipGraphCreate",
    "hipGraphDebugDotPrint",
    "hipGraphDestroy",
    "hipGraphDestroyNode",
    "hipGraphEventRecordNodeGetEvent",
    "hipGraphEventRecordNodeSetEvent",
    "hipGraphEventWaitNodeGetEvent",
    "hipGraphEventWaitNodeSetEvent",
    "hipGraphExecChildGraphNodeSetParams",
    "hipGraphExecDestroy",
    "hipGraphExecEventRecordNodeSetEvent",
    "hipGraphExecEventWaitNodeSetEvent",
    "hipGraphExecHostNodeSetParams",
    "hipGraphExecKernelNodeSetParams",
    "hipGraphExecMemcpyNodeSetParams",
    "hipGraphExecMemcpyNodeSetParams1D",
    "hipGraphExecMemcpyNodeSetParamsFromSymbol",
    "hipGraphExecMemcpyNodeSetParamsToSymbol",
    "hipGraphExecMemsetNodeSetParams",
    "hipGraphExecUpdate",
    "hipGraphGetEdges",
    "hipGraphGetNodes",
    "hipGraphGetRootNodes",
    "hipGraphHostNodeGetParams",
    "hipGraphHostNodeSetParams",
    "hipGraphInstantiate",
    "hipGraphInstantiateWithFlags",
    "hipGraphKernelNodeCopyAttributes",
    "hipGraphKernelNodeGetAttribute",
    "hipGraphKernelNodeGetParams",
    "hipGraphKernelNodeSetAttribute",
    "hipGraphKernelNodeSetParams",
    "hipGraphLaunch",
    "hipGraphMemAllocNodeGetParams",
    "hipGraphMemFreeNodeGetParams",
    "hipGraphMemcpyNodeGetParams",
    "hipGraphMemcpyNodeSetParams",
    "hipGraphMemcpyNodeSetParams1D",
    "hipGraphMemcpyNodeSetParamsFromSymbol",
    "hipGraphMemcpyNodeSetParamsToSymbol",
    "hipGraphMemsetNodeGetParams",
    "hipGraphMemsetNodeSetParams",
    "hipGraphNodeFindInClone",
    "hipGraphNodeGetDependencies",
    "hipGraphNodeGetDependentNodes",
    "hipGraphNodeGetEnabled",
    "hipGraphNodeGetType",
    "hipGraphNodeSetEnabled",
    "hipGraphReleaseUserObject",
    "hipGraphRemoveDependencies",
    "hipGraphRetainUserObject",
    "hipGraphUpload",
    "hipGraphicsGLRegisterBuffer",
    "hipGraphicsGLRegisterImage",
    "hipGraphicsMapResources",
    "hipGraphicsResourceGetMappedPointer",
    "hipGraphicsSubResourceGetMappedArray",
    "hipGraphicsUnmapResources",
    "hipGraphicsUnregisterResource",
    "hipHostAlloc",
    "hipHostFree",
    "hipHostGetDevicePointer",
    "hipHostGetFlags",
    "hipHostMalloc",
    "hipHostRegister",
    "hipHostUnregister",
    "hipImportExternalMemory",
    "hipImportExternalSemaphore",
    "hipInit",
    "hipIpcCloseMemHandle",
    "hipIpcGetEventHandle",
    "hipIpcGetMemHandle",
    "hipIpcOpenEventHandle",
    "hipIpcOpenMemHandle",
    "hipKernelNameRef",
    "hipKernelNameRefByPtr",
    "hipLaunchByPtr",
    "hipLaunchCooperativeKernel",
    "hipLaunchCooperativeKernelMultiDevice",
    "hipLaunchHostFunc",
    "hipLaunchKernel",
    "hipMalloc",
    "hipMalloc3D",
    "hipMalloc3DArray",
    "hipMallocArray",
    "hipMallocAsync",
    "hipMallocFromPoolAsync",
    "hipMallocHost",
    "hipMallocManaged",
    "hipMallocMipmappedArray",
    "hipMallocPitch",
    "hipMemAddressFree",
    "hipMemAddressReserve",
    "hipMemAdvise",
    "hipMemAdvise_v2",
    "hipMemAllocHost",
    "hipMemAllocPitch",
    "hipMemCreate",
    "hipMemExportToShareableHandle",
    "hipMemGetAccess",
    "hipMemGetAddressRange",
    "hipMemGetAllocationGranularity",
    "hipMemGetAllocationPropertiesFromHandle",
    "hipMemGetInfo",
    "hipMemImportFromShareableHandle",
    "hipMemMap",
    "hipMemMapArrayAsync",
    "hipMemPoolCreate",
    "hipMemPoolDestroy",
    "hipMemPoolExportPointer",
    "hipMemPoolExportToShareableHandle",
    "hipMemPoolGetAccess",
    "hipMemPoolGetAttribute",
    "hipMemPoolImportFromShareableHandle",
    "hipMemPoolImportPointer",
    "hipMemPoolSetAccess",
    "hipMemPoolSetAttribute",
    "hipMemPoolTrimTo",
    "hipMemPrefetchAsync",
    "hipMemPrefetchAsync_v2",
    "hipMemPrefetchBatchAsync",
    "hipMemDiscardBatchAsync",
    "hipDrvMemDiscardBatchAsync",
    "hipMemDiscardAndPrefetchBatchAsync",
    "hipDrvMemDiscardAndPrefetchBatchAsync",
    "hipMemPtrGetInfo",
    "hipMemRangeGetAttribute",
    "hipMemRangeGetAttributes",
    "hipMemRelease",
    "hipMemRetainAllocationHandle",
    "hipMemSetAccess",
    "hipMemUnmap",
    "hipMemcpy",
    "hipMemcpy2D",
    "hipMemcpy2DAsync",
    "hipMemcpy2DFromArray",
    "hipMemcpy2DFromArrayAsync",
    "hipMemcpy2DToArray",
    "hipMemcpy2DToArrayAsync",
    "hipMemcpy3D",
    "hipMemcpy3DAsync",
    "hipMemcpyAsync",
    "hipMemcpyAtoH",
    "hipMemcpyDtoD",
    "hipMemcpyDtoDAsync",
    "hipMemcpyDtoH",
    "hipMemcpyDtoHAsync",
    "hipMemcpyFromArray",
    "hipMemcpyFromSymbol",
    "hipMemcpyFromSymbolAsync",
    "hipMemcpyHtoA",
    "hipMemcpyHtoD",
    "hipMemcpyHtoDAsync",
    "hipMemcpyParam2D",
    "hipMemcpyParam2DAsync",
    "hipMemcpyPeer",
    "hipMemcpyPeerAsync",
    "hipMemcpyToArray",
    "hipMemcpyToSymbol",
    "hipMemcpyToSymbolAsync",
    "hipMemcpyWithStream",
    "hipMemset",
    "hipMemset2D",
    "hipMemset2DAsync",
    "hipMemset3D",
    "hipMemset3DAsync",
    "hipMemsetAsync",
    "hipMemsetD16",
    "hipMemsetD16Async",
    "hipMemsetD32",
    "hipMemsetD32Async",
    "hipMemsetD8",
    "hipMemsetD8Async",
    "hipMipmappedArrayCreate",
    "hipMipmappedArrayDestroy",
    "hipMipmappedArrayGetLevel",
    "hipModuleGetFunction",
    "hipModuleGetFunctionCount",
    "hipModuleGetGlobal",
    "hipModuleGetTexRef",
    "hipModuleLaunchCooperativeKernel",
    "hipModuleLaunchCooperativeKernelMultiDevice",
    "hipModuleLaunchKernel",
    "hipModuleLoad",
    "hipModuleLoadData",
    "hipModuleLoadDataEx",
    "hipLinkAddData",
    "hipLinkAddFile",
    "hipLinkComplete",
    "hipLinkCreate",
    "hipLinkDestroy",
    "hipModuleOccupancyMaxActiveBlocksPerMultiprocessor",
    "hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags",
    "hipModuleOccupancyMaxPotentialBlockSize",
    "hipModuleOccupancyMaxPotentialBlockSizeWithFlags",
    "hipModuleUnload",
    "hipOccupancyAvailableDynamicSMemPerBlock",
    "hipOccupancyMaxActiveBlocksPerMultiprocessor",
    "hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags",
    "hipOccupancyMaxPotentialBlockSize",
    "hipOccupancyMaxActiveClusters",
    "hipOccupancyMaxPotentialClusterSize",
    "hipPeekAtLastError",
    "hipPointerGetAttribute",
    "hipPointerGetAttributes",
    "hipPointerSetAttribute",
    "hipProfilerStart",
    "hipProfilerStop",
    "hipRuntimeGetVersion",
    "hipSetDevice",
    "hipSetDeviceFlags",
    "hipSetupArgument",
    "hipSignalExternalSemaphoresAsync",
    "hipStreamAddCallback",
    "hipStreamAttachMemAsync",
    "hipStreamBeginCapture",
    "hipStreamCopyAttributes",
    "hipStreamCreate",
    "hipStreamCreateWithFlags",
    "hipStreamCreateWithPriority",
    "hipStreamDestroy",
    "hipStreamEndCapture",
    "hipStreamGetCaptureInfo",
    "hipStreamGetCaptureInfo_v2",
    "hipStreamGetDevice",
    "hipStreamGetFlags",
    "hipStreamGetId",
    "hipStreamGetPriority",
    "hipStreamIsCapturing",
    "hipStreamQuery",
    "hipStreamSynchronize",
    "hipStreamUpdateCaptureDependencies",
    "hipStreamWaitEvent",
    "hipStreamWaitValue32",
    "hipStreamWaitValue64",
    "hipStreamWriteValue32",
    "hipStreamWriteValue64",
    "hipStreamBatchMemOp",
    "hipTexObjectCreate",
    "hipTexObjectDestroy",
    "hipTexObjectGetResourceDesc",
    "hipTexObjectGetResourceViewDesc",
    "hipTexObjectGetTextureDesc",
    "hipTexRefGetAddress",
    "hipTexRefGetAddressMode",
    "hipTexRefGetFilterMode",
    "hipTexRefGetFlags",
    "hipTexRefGetFormat",
    "hipTexRefGetMaxAnisotropy",
    "hipTexRefGetMipMappedArray",
    "hipTexRefGetMipmapFilterMode",
    "hipTexRefGetMipmapLevelBias",
    "hipTexRefGetMipmapLevelClamp",
    "hipTexRefSetAddress",
    "hipTexRefSetAddress2D",
    "hipTexRefSetAddressMode",
    "hipTexRefSetArray",
    "hipTexRefSetBorderColor",
    "hipTexRefSetFilterMode",
    "hipTexRefSetFlags",
    "hipTexRefSetFormat",
    "hipTexRefSetMaxAnisotropy",
    "hipTexRefSetMipmapFilterMode",
    "hipTexRefSetMipmapLevelBias",
    "hipTexRefSetMipmapLevelClamp",
    "hipTexRefSetMipmappedArray",
    "hipThreadExchangeStreamCaptureMode",
    "hipUnbindTexture",
    "hipUserObjectCreate",
    "hipUserObjectRelease",
    "hipUserObjectRetain",
    "hipWaitExternalSemaphoresAsync",
    "hipMemcpy_spt",
    "hipMemcpyToSymbol_spt",
    "hipMemcpyFromSymbol_spt",
    "hipMemcpy2D_spt",
    "hipMemcpy2DFromArray_spt",
    "hipMemcpy3D_spt",
    "hipMemset_spt",
    "hipMemsetAsync_spt",
    "hipMemset2D_spt",
    "hipMemset2DAsync_spt",
    "hipMemset3DAsync_spt",
    "hipMemset3D_spt",
    "hipMemcpyAsync_spt",
    "hipMemcpy3DAsync_spt",
    "hipMemcpy2DAsync_spt",
    "hipMemcpyFromSymbolAsync_spt",
    "hipMemcpyToSymbolAsync_spt",
    "hipMemcpyFromArray_spt",
    "hipMemcpy2DToArray_spt",
    "hipMemcpy2DFromArrayAsync_spt",
    "hipMemcpy2DToArrayAsync_spt",
    "hipStreamQuery_spt",
    "hipStreamSynchronize_spt",
    "hipStreamGetPriority_spt",
    "hipStreamWaitEvent_spt",
    "hipStreamGetFlags_spt",
    "hipStreamAddCallback_spt",
    "hipEventRecord_spt",
    "hipLaunchCooperativeKernel_spt",
    "hipLaunchKernel_spt",
    "hipGraphLaunch_spt",
    "hipStreamBeginCapture_spt",
    "hipStreamEndCapture_spt",
    "hipStreamIsCapturing_spt",
    "hipStreamGetCaptureInfo_spt",
    "hipStreamGetCaptureInfo_v2_spt",
    "hipLaunchHostFunc_spt",
    "hipCreateChannelDesc",
    "hipExtModuleLaunchKernel",
    "hipHccModuleLaunchKernel",
    "hipGetStreamDeviceId",
    "hipDrvGraphAddMemsetNode",
    "hipGraphAddExternalSemaphoresWaitNode",
    "hipGraphAddExternalSemaphoresSignalNode",
    "hipGraphExternalSemaphoresSignalNodeSetParams",
    "hipGraphExternalSemaphoresWaitNodeSetParams",
    "hipGraphExternalSemaphoresSignalNodeGetParams",
    "hipGraphExternalSemaphoresWaitNodeGetParams",
    "hipGraphExecExternalSemaphoresSignalNodeSetParams",
    "hipGraphExecExternalSemaphoresWaitNodeSetParams",
    "hipGraphAddNode",
    "hipGraphInstantiateWithParams",
    "hipExtGetLastError",
    "hipTexRefGetBorderColor",
    "hipTexRefGetArray",
    "hipGetProcAddress",
    "hipStreamBeginCaptureToGraph",
    "hipGetFuncBySymbol",
    "hipDrvGraphAddMemFreeNode",
    "hipDrvGraphExecMemcpyNodeSetParams",
    "hipDrvGraphExecMemsetNodeSetParams",
    "hipSetValidDevices",
    "hipMemcpyAtoD",
    "hipMemcpyDtoA",
    "hipMemcpyAtoA",
    "hipMemcpyAtoHAsync",
    "hipMemcpyHtoAAsync",
    "hipMemcpy2DArrayToArray",
    "hipGraphExecGetFlags",
    "hipGraphNodeSetParams",
    "hipGraphExecNodeSetParams",
    "hipExternalMemoryGetMappedMipmappedArray",
    "hipDrvGraphMemcpyNodeGetParams",
    "hipDrvGraphMemcpyNodeSetParams",
    "hipExtHostAlloc",
    "hipDeviceGetTexture1DLinearMaxWidth",
    "hipGraphAddBatchMemOpNode",
    "hipGraphBatchMemOpNodeGetParams",
    "hipGraphBatchMemOpNodeSetParams",
    "hipGraphExecBatchMemOpNodeSetParams",
    "hipEventRecordWithFlags",
    "hipLaunchKernelExC",
    "hipDrvLaunchKernelEx",
    "hipMemGetHandleForAddressRange",
    "hipMemsetD2D8",
    "hipMemsetD2D8Async",
    "hipMemsetD2D16",
    "hipMemsetD2D16Async",
    "hipMemsetD2D32",
    "hipMemsetD2D32Async",
    "hipStreamSetAttribute",
    "hipStreamGetAttribute",
    "hipModuleLoadFatBinary",
    "hipMemcpyBatchAsync",
    "hipMemcpy3DBatchAsync",
    "hipMemcpy3DPeer",
    "hipMemcpy3DPeerAsync",
    "hipGetDriverEntryPoint",
    "hipGetDriverEntryPoint_spt",
    "hipLibraryLoadData",
    "hipLibraryLoadFromFile",
    "hipLibraryUnload",
    "hipLibraryGetKernel",
    "hipLibraryGetKernelCount",
    "hipLibraryGetGlobal",
    "hipLibraryGetManaged",
    "hipLibraryEnumerateKernels",
    "hipKernelGetLibrary",
    "hipKernelGetName",
    "hipGetProcAddress_spt",
    "hipExtDisableLogging",
    "hipExtEnableLogging",
    "hipExtSetLoggingParams",
    "hipKernelGetAttribute",
    "hipKernelSetAttribute",
    "hipKernelGetFunction",
    "hipKernelGetParamInfo",
    "hipMemSetMemPool",
    "hipMemGetMemPool",
    "hipMipmappedArrayGetMemoryRequirements",
    "hipGreenCtxCreate",
    "hipExecutionCtxDestroy",
    "hipExecutionCtxStreamCreate",
    "hipDeviceGetDevResource",
    "hipDevSmResourceSplitByCount",
    "hipDevSmResourceSplit",
    "hipDevResourceGenerateDesc",
    "hipDeviceGetExecutionCtx",
    "hipExecutionCtxGetDevResource",
    "hipExecutionCtxGetDevice",
    "hipExecutionCtxGetId",
    "hipStreamGetDevResource",
    "hipExecutionCtxRecordEvent",
    "hipExecutionCtxSynchronize",
    "hipExecutionCtxWaitEvent",
};
#else
extern const char* const hrr_api_names[HRR_API_COUNT];
#endif


#pragma pack(pop)
