/*
 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
 *
 * SPDX-License-Identifier: MIT
 */
/* ============================================================================
 * hip_playback_generated.cpp  -  AUTO-GENERATED by gen_hrr_api_args.py
 * DO NOT EDIT MANUALLY.
 * Regenerate with:
 *     python gen_hrr_api_args.py
 *
 * Contains:
 *   - playback_hipFoo() for every HIP API
 *     Signature: hipError_t playback_foo(PlaybackContext&, const uint8_t*)
 *   - hrr_playback_dispatch[HRR_API_COUNT]  — indexed by hrr_api_id_t
 * ============================================================================ */

#include "hip_playback.h"
#include "hrr_api_args.h"
#include <hip/hip_runtime.h>
#include <cstring>

// Manual playback implementations (extern'd below) are in hip_playback.cpp
// Compiler APIs are no-ops during playback


// ============================================================
// Playback shims
// ============================================================

static hipError_t playback___hipPopCallConfiguration(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback___hipPushCallConfiguration(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

extern hipError_t playback___hipRegisterFatBinary(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback___hipRegisterFunction(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback___hipRegisterManagedVar(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback___hipRegisterSurface(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback___hipRegisterTexture(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback___hipRegisterVar(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback___hipUnregisterFatBinary(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  return hipSuccess;
}

static hipError_t playback_hipApiName(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipApiName — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipArray3DCreate(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipArray3DGetDescriptor(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipArray3DGetDescriptor — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipArrayCreate(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipArrayDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipArrayDestroy — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipArrayGetDescriptor(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipArrayGetDescriptor — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipArrayGetInfo(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipArrayGetInfo — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipBindTexture(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipBindTexture*>(payload);
  size_t _out_offset{};
  const hipChannelFormatDesc* _s_desc{};
  hipError_t _r = (hipError_t)hipBindTexture(&_out_offset, (const textureReference*)a->tex, ctx.translate_ptr(a->devPtr), _s_desc, (size_t)a->size);
  return _r;
}

static hipError_t playback_hipBindTexture2D(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipBindTexture2D*>(payload);
  size_t _out_offset{};
  const hipChannelFormatDesc* _s_desc{};
  hipError_t _r = (hipError_t)hipBindTexture2D(&_out_offset, (const textureReference*)a->tex, ctx.translate_ptr(a->devPtr), _s_desc, (size_t)a->width, (size_t)a->height, (size_t)a->pitch);
  return _r;
}

static hipError_t playback_hipBindTextureToArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipBindTextureToArray*>(payload);
  const hipChannelFormatDesc* _s_desc{};
  hipError_t _r = (hipError_t)hipBindTextureToArray((const textureReference*)a->tex, (hipArray_t)ctx.translate_array(a->array), _s_desc);
  return _r;
}

static hipError_t playback_hipBindTextureToMipmappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipBindTextureToMipmappedArray*>(payload);
  const hipChannelFormatDesc* _s_desc{};
  hipError_t _r = (hipError_t)hipBindTextureToMipmappedArray((const textureReference*)a->tex, (hipMipmappedArray_t)ctx.translate_mipmapped(a->mipmappedArray), _s_desc);
  return _r;
}

static hipError_t playback_hipChooseDevice(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipChooseDevice — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipChooseDeviceR0000(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipChooseDeviceR0000 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipConfigureCall(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipConfigureCall*>(payload);
  dim3 _dim_gridDim(a->gridDim_x, a->gridDim_y, a->gridDim_z);
  dim3 _dim_blockDim(a->blockDim_x, a->blockDim_y, a->blockDim_z);
  hipError_t _r = (hipError_t)hipConfigureCall(_dim_gridDim, _dim_blockDim, (size_t)a->sharedMem, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipCreateSurfaceObject(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipCreateSurfaceObject*>(payload);
  hipSurfaceObject_t _out_pSurfObject = 0;
  hipError_t _r = (hipError_t)hipCreateSurfaceObject(&_out_pSurfObject, (const hipResourceDesc*)a->pResDesc);
  if (_r == hipSuccess) {
    ctx.record_surface(a->pSurfObject, _out_pSurfObject);
  }
  return _r;
}

static hipError_t playback_hipCreateTextureObject(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCreateTextureObject — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxCreate(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxCreate — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipCtxDestroy*>(payload);
  hipError_t _r = (hipError_t)hipCtxDestroy((hipCtx_t)a->ctx);
  return _r;
}

static hipError_t playback_hipCtxDisablePeerAccess(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxDisablePeerAccess — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxEnablePeerAccess(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxEnablePeerAccess — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxGetApiVersion(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxGetApiVersion — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxGetCacheConfig(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxGetCacheConfig — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxGetCurrent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxGetCurrent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxGetDevice(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxGetDevice — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxGetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxGetFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxGetSharedMemConfig(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxGetSharedMemConfig — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxPopCurrent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxPopCurrent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxPushCurrent(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipCtxPushCurrent*>(payload);
  hipError_t _r = (hipError_t)hipCtxPushCurrent((hipCtx_t)a->ctx);
  return _r;
}

static hipError_t playback_hipCtxSetCacheConfig(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipCtxSetCacheConfig*>(payload);
  hipError_t _r = (hipError_t)hipCtxSetCacheConfig((hipFuncCache_t)a->cacheConfig);
  return _r;
}

static hipError_t playback_hipCtxSetCurrent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCtxSetCurrent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipCtxSetSharedMemConfig(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipCtxSetSharedMemConfig*>(payload);
  hipError_t _r = (hipError_t)hipCtxSetSharedMemConfig((hipSharedMemConfig)a->config);
  return _r;
}

static hipError_t playback_hipCtxSynchronize(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipCtxSynchronize*>(payload);
  hipError_t _r = (hipError_t)hipCtxSynchronize();
  return _r;
}

static hipError_t playback_hipDestroyExternalMemory(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDestroyExternalMemory*>(payload);
  hipError_t _r = (hipError_t)hipDestroyExternalMemory((hipExternalMemory_t)a->extMem);
  return _r;
}

static hipError_t playback_hipDestroyExternalSemaphore(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDestroyExternalSemaphore*>(payload);
  hipError_t _r = (hipError_t)hipDestroyExternalSemaphore((hipExternalSemaphore_t)a->extSem);
  return _r;
}

static hipError_t playback_hipDestroySurfaceObject(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDestroySurfaceObject*>(payload);
  uint64_t _rec_hdl = a->surfaceObject;
  hipError_t _r = (hipError_t)hipDestroySurfaceObject((hipSurfaceObject_t)ctx.translate_surface(_rec_hdl));
  if (_r == hipSuccess) {
    ctx.remove_surface(_rec_hdl);
  }
  return _r;
}

static hipError_t playback_hipDestroyTextureObject(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDestroyTextureObject — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceCanAccessPeer(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceCanAccessPeer*>(payload);
  int _out_canAccessPeer{};
  hipError_t _r = (hipError_t)hipDeviceCanAccessPeer(&_out_canAccessPeer, (int)a->deviceId, (int)a->peerDeviceId);
  return _r;
}

static hipError_t playback_hipDeviceComputeCapability(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceComputeCapability*>(payload);
  int _out_major{};
  int _out_minor{};
  hipError_t _r = (hipError_t)hipDeviceComputeCapability(&_out_major, &_out_minor, (hipDevice_t)a->device);
  return _r;
}

static hipError_t playback_hipDeviceDisablePeerAccess(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceDisablePeerAccess*>(payload);
  hipError_t _r = (hipError_t)hipDeviceDisablePeerAccess((int)a->peerDeviceId);
  return _r;
}

static hipError_t playback_hipDeviceEnablePeerAccess(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceEnablePeerAccess*>(payload);
  hipError_t _r = (hipError_t)hipDeviceEnablePeerAccess((int)a->peerDeviceId, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipDeviceGet(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGet — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetAttribute*>(payload);
  int _out_pi{};
  hipError_t _r = (hipError_t)hipDeviceGetAttribute(&_out_pi, (hipDeviceAttribute_t)a->attr, (int)a->deviceId);
  return _r;
}

static hipError_t playback_hipDeviceGetByPCIBusId(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGetByPCIBusId — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGetCacheConfig(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetCacheConfig*>(payload);
  hipFuncCache_t _out_cacheConfig{};
  hipError_t _r = (hipError_t)hipDeviceGetCacheConfig(&_out_cacheConfig);
  return _r;
}

static hipError_t playback_hipDeviceGetDefaultMemPool(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetDefaultMemPool*>(payload);
  hipMemPool_t _out_mem_pool = nullptr;
  hipError_t _r = (hipError_t)hipDeviceGetDefaultMemPool(&_out_mem_pool, (int)a->device);
  return _r;
}

static hipError_t playback_hipDeviceGetGraphMemAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGetGraphMemAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGetLimit(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetLimit*>(payload);
  size_t _out_pValue{};
  hipError_t _r = (hipError_t)hipDeviceGetLimit(&_out_pValue, (enum hipLimit_t)a->limit);
  return _r;
}

static hipError_t playback_hipDeviceGetMemPool(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetMemPool*>(payload);
  hipMemPool_t _out_mem_pool = nullptr;
  hipError_t _r = (hipError_t)hipDeviceGetMemPool(&_out_mem_pool, (int)a->device);
  return _r;
}

static hipError_t playback_hipDeviceGetName(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGetName — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGetP2PAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetP2PAttribute*>(payload);
  int _out_value{};
  hipError_t _r = (hipError_t)hipDeviceGetP2PAttribute(&_out_value, (hipDeviceP2PAttr)a->attr, (int)a->srcDevice, (int)a->dstDevice);
  return _r;
}

static hipError_t playback_hipDeviceGetPCIBusId(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGetPCIBusId — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGetSharedMemConfig(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetSharedMemConfig*>(payload);
  hipSharedMemConfig _out_pConfig{};
  hipError_t _r = (hipError_t)hipDeviceGetSharedMemConfig(&_out_pConfig);
  return _r;
}

static hipError_t playback_hipDeviceGetStreamPriorityRange(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetStreamPriorityRange*>(payload);
  int _out_leastPriority{};
  int _out_greatestPriority{};
  hipError_t _r = (hipError_t)hipDeviceGetStreamPriorityRange(&_out_leastPriority, &_out_greatestPriority);
  return _r;
}

static hipError_t playback_hipDeviceGetUuid(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGetUuid — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGraphMemTrim(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGraphMemTrim*>(payload);
  hipError_t _r = (hipError_t)hipDeviceGraphMemTrim((int)a->device);
  return _r;
}

static hipError_t playback_hipDevicePrimaryCtxGetState(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDevicePrimaryCtxGetState — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDevicePrimaryCtxRelease(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDevicePrimaryCtxRelease — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDevicePrimaryCtxReset(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDevicePrimaryCtxReset — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDevicePrimaryCtxRetain(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDevicePrimaryCtxRetain — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDevicePrimaryCtxSetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDevicePrimaryCtxSetFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceReset(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceReset*>(payload);
  hipError_t _r = (hipError_t)hipDeviceReset();
  return _r;
}

static hipError_t playback_hipDeviceSetCacheConfig(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceSetCacheConfig*>(payload);
  hipError_t _r = (hipError_t)hipDeviceSetCacheConfig((hipFuncCache_t)a->cacheConfig);
  return _r;
}

static hipError_t playback_hipDeviceSetGraphMemAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceSetGraphMemAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceSetLimit(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceSetLimit*>(payload);
  hipError_t _r = (hipError_t)hipDeviceSetLimit((enum hipLimit_t)a->limit, (size_t)a->value);
  return _r;
}

static hipError_t playback_hipDeviceSetMemPool(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceSetMemPool*>(payload);
  hipError_t _r = (hipError_t)hipDeviceSetMemPool((int)a->device, (hipMemPool_t)ctx.translate_mempool(a->mem_pool));
  return _r;
}

static hipError_t playback_hipDeviceSetSharedMemConfig(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceSetSharedMemConfig*>(payload);
  hipError_t _r = (hipError_t)hipDeviceSetSharedMemConfig((hipSharedMemConfig)a->config);
  return _r;
}

static hipError_t playback_hipDeviceSynchronize(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceSynchronize*>(payload);
  hipError_t _r = (hipError_t)hipDeviceSynchronize();
  return _r;
}

static hipError_t playback_hipDeviceTotalMem(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceTotalMem*>(payload);
  size_t _out_bytes{};
  hipError_t _r = (hipError_t)hipDeviceTotalMem(&_out_bytes, (hipDevice_t)a->device);
  return _r;
}

static hipError_t playback_hipDriverGetVersion(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDriverGetVersion*>(payload);
  int _out_driverVersion{};
  hipError_t _r = (hipError_t)hipDriverGetVersion(&_out_driverVersion);
  return _r;
}

static hipError_t playback_hipDrvGetErrorName(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGetErrorName — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGetErrorString(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGetErrorString — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGraphAddMemcpyNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphAddMemcpyNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvMemcpy2DUnaligned(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvMemcpy2DUnaligned — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvMemcpy3D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvMemcpy3D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvMemcpy3DAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvMemcpy3DAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvPointerGetAttributes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvPointerGetAttributes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipEventCreate(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipEventCreateWithFlags(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipEventDestroy(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipEventElapsedTime(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipEventElapsedTime*>(payload);
  float _out_ms{};
  hipError_t _r = (hipError_t)hipEventElapsedTime(&_out_ms, (hipEvent_t)ctx.translate_event(a->start), (hipEvent_t)ctx.translate_event(a->stop));
  return _r;
}

static hipError_t playback_hipEventQuery(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipEventQuery*>(payload);
  hipError_t _r = (hipError_t)hipEventQuery((hipEvent_t)ctx.translate_event(a->event));
  return _r;
}

static hipError_t playback_hipEventRecord(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipEventRecord*>(payload);
  hipError_t _r = (hipError_t)hipEventRecord((hipEvent_t)ctx.translate_event(a->event), (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipEventSynchronize(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipEventSynchronize*>(payload);
  hipError_t _r = (hipError_t)hipEventSynchronize((hipEvent_t)ctx.translate_event(a->event));
  return _r;
}

static hipError_t playback_hipExtGetLinkTypeAndHopCount(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipExtGetLinkTypeAndHopCount — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExtLaunchKernel(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipExtLaunchKernel — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExtLaunchMultiKernelMultiDevice(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExtLaunchMultiKernelMultiDevice*>(payload);
  hipLaunchParams _out_launchParamsList{};
  hipError_t _r = (hipError_t)hipExtLaunchMultiKernelMultiDevice(&_out_launchParamsList, (int)a->numDevices, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipExtMallocWithFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipExtMallocWithFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExtStreamCreateWithCUMask(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipExtStreamCreateWithCUMask — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExtStreamGetCUMask(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipExtStreamGetCUMask — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExternalMemoryGetMappedBuffer(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExternalMemoryGetMappedBuffer*>(payload);
  void* _out_devPtr = nullptr;
  hipError_t _r = (hipError_t)hipExternalMemoryGetMappedBuffer((void**)&_out_devPtr, (hipExternalMemory_t)a->extMem, (const hipExternalMemoryBufferDesc*)a->bufferDesc);
  return _r;
}

extern hipError_t playback_hipFree(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipFreeArray(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipFreeAsync(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipFreeHost(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFreeHost — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipFreeMipmappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFreeMipmappedArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipFuncGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFuncGetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipFuncGetAttributes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFuncGetAttributes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipFuncSetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFuncSetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipFuncSetCacheConfig(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFuncSetCacheConfig — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipFuncSetSharedMemConfig(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipFuncSetSharedMemConfig — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGLGetDevices(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGLGetDevices — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetChannelDesc(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetChannelDesc — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetDevice(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetDevice*>(payload);
  int _out_deviceId{};
  hipError_t _r = (hipError_t)hipGetDevice(&_out_deviceId);
  return _r;
}

static hipError_t playback_hipGetDeviceCount(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetDeviceCount*>(payload);
  int _out_count{};
  hipError_t _r = (hipError_t)hipGetDeviceCount(&_out_count);
  return _r;
}

static hipError_t playback_hipGetDeviceFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetDeviceFlags*>(payload);
  unsigned int _out_flags{};
  hipError_t _r = (hipError_t)hipGetDeviceFlags(&_out_flags);
  return _r;
}

static hipError_t playback_hipGetDevicePropertiesR0600(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetDevicePropertiesR0600*>(payload);
  hipDeviceProp_tR0600 _out_prop{};
  hipError_t _r = (hipError_t)hipGetDevicePropertiesR0600(&_out_prop, (int)a->device);
  return _r;
}

static hipError_t playback_hipGetDevicePropertiesR0000(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetDevicePropertiesR0000 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetErrorName(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetErrorName — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetErrorString(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetErrorString — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetLastError(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetLastError*>(payload);
  hipError_t _r = (hipError_t)hipGetLastError();
  return _r;
}

static hipError_t playback_hipGetMipmappedArrayLevel(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetMipmappedArrayLevel — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetSymbolAddress(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetSymbolAddress — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetSymbolSize(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetSymbolSize — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetTextureAlignmentOffset(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetTextureAlignmentOffset*>(payload);
  size_t _out_offset{};
  hipError_t _r = (hipError_t)hipGetTextureAlignmentOffset(&_out_offset, (const textureReference*)a->texref);
  return _r;
}

static hipError_t playback_hipGetTextureObjectResourceDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetTextureObjectResourceDesc*>(payload);
  hipResourceDesc _out_pResDesc{};
  hipError_t _r = (hipError_t)hipGetTextureObjectResourceDesc(&_out_pResDesc, (hipTextureObject_t)ctx.translate_texture(a->textureObject));
  return _r;
}

static hipError_t playback_hipGetTextureObjectResourceViewDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetTextureObjectResourceViewDesc*>(payload);
  struct hipResourceViewDesc _out_pResViewDesc{};
  hipError_t _r = (hipError_t)hipGetTextureObjectResourceViewDesc(&_out_pResViewDesc, (hipTextureObject_t)ctx.translate_texture(a->textureObject));
  return _r;
}

static hipError_t playback_hipGetTextureObjectTextureDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetTextureObjectTextureDesc*>(payload);
  hipTextureDesc _out_pTexDesc{};
  hipError_t _r = (hipError_t)hipGetTextureObjectTextureDesc(&_out_pTexDesc, (hipTextureObject_t)ctx.translate_texture(a->textureObject));
  return _r;
}

static hipError_t playback_hipGetTextureReference(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetTextureReference — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddChildGraphNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddChildGraphNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddDependencies(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddDependencies — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddEmptyNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddEmptyNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddEventRecordNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddEventRecordNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddEventWaitNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddEventWaitNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddHostNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddHostNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddKernelNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddKernelNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemAllocNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemAllocNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemFreeNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemFreeNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemcpyNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemcpyNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemcpyNode1D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemcpyNode1D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemcpyNodeFromSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemcpyNodeFromSymbol — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemcpyNodeToSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemcpyNodeToSymbol — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddMemsetNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddMemsetNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphChildGraphNodeGetGraph(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphChildGraphNodeGetGraph — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphClone(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphClone — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphCreate(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphCreate — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphDebugDotPrint(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphDebugDotPrint — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphDestroy — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphDestroyNode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphDestroyNode*>(payload);
  hipError_t _r = (hipError_t)hipGraphDestroyNode((hipGraphNode_t)a->node);
  return _r;
}

static hipError_t playback_hipGraphEventRecordNodeGetEvent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphEventRecordNodeGetEvent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphEventRecordNodeSetEvent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphEventRecordNodeSetEvent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphEventWaitNodeGetEvent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphEventWaitNodeGetEvent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphEventWaitNodeSetEvent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphEventWaitNodeSetEvent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecChildGraphNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecChildGraphNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecDestroy — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecEventRecordNodeSetEvent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecEventRecordNodeSetEvent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecEventWaitNodeSetEvent(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecEventWaitNodeSetEvent — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecHostNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecHostNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecKernelNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecKernelNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecMemcpyNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecMemcpyNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecMemcpyNodeSetParams1D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecMemcpyNodeSetParams1D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecMemcpyNodeSetParamsFromSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExecMemcpyNodeSetParamsFromSymbol*>(payload);
  hipError_t _r = (hipError_t)hipGraphExecMemcpyNodeSetParamsFromSymbol((hipGraphExec_t)ctx.translate_graph_exec(a->hGraphExec), (hipGraphNode_t)a->node, ctx.translate_ptr(a->dst), (const void*)a->symbol, (size_t)a->count, (size_t)a->offset, (hipMemcpyKind)a->kind);
  return _r;
}

static hipError_t playback_hipGraphExecMemcpyNodeSetParamsToSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExecMemcpyNodeSetParamsToSymbol*>(payload);
  hipError_t _r = (hipError_t)hipGraphExecMemcpyNodeSetParamsToSymbol((hipGraphExec_t)ctx.translate_graph_exec(a->hGraphExec), (hipGraphNode_t)a->node, (const void*)a->symbol, ctx.translate_ptr(a->src), (size_t)a->count, (size_t)a->offset, (hipMemcpyKind)a->kind);
  return _r;
}

static hipError_t playback_hipGraphExecMemsetNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecMemsetNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecUpdate(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecUpdate — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphGetEdges(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphGetEdges — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphGetNodes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphGetNodes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphGetRootNodes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphGetRootNodes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphHostNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphHostNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphHostNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphHostNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipGraphInstantiate(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipGraphInstantiateWithFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphInstantiateWithFlags*>(payload);
  hipGraphExec_t _out_pGraphExec = nullptr;
  hipError_t _r = (hipError_t)hipGraphInstantiateWithFlags(&_out_pGraphExec, (hipGraph_t)ctx.translate_graph(a->graph), (unsigned long long)a->flags);
  if (_r == hipSuccess) {
    ctx.record_graph_exec(a->pGraphExec, _out_pGraphExec);
  }
  return _r;
}

static hipError_t playback_hipGraphKernelNodeCopyAttributes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphKernelNodeCopyAttributes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphKernelNodeGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphKernelNodeGetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphKernelNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphKernelNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphKernelNodeSetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphKernelNodeSetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphKernelNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphKernelNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipGraphLaunch(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipGraphMemAllocNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemAllocNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphMemFreeNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemFreeNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphMemcpyNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemcpyNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphMemcpyNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemcpyNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphMemcpyNodeSetParams1D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemcpyNodeSetParams1D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphMemcpyNodeSetParamsFromSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphMemcpyNodeSetParamsFromSymbol*>(payload);
  hipError_t _r = (hipError_t)hipGraphMemcpyNodeSetParamsFromSymbol((hipGraphNode_t)a->node, ctx.translate_ptr(a->dst), (const void*)a->symbol, (size_t)a->count, (size_t)a->offset, (hipMemcpyKind)a->kind);
  return _r;
}

static hipError_t playback_hipGraphMemcpyNodeSetParamsToSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphMemcpyNodeSetParamsToSymbol*>(payload);
  hipError_t _r = (hipError_t)hipGraphMemcpyNodeSetParamsToSymbol((hipGraphNode_t)a->node, (const void*)a->symbol, ctx.translate_ptr(a->src), (size_t)a->count, (size_t)a->offset, (hipMemcpyKind)a->kind);
  return _r;
}

static hipError_t playback_hipGraphMemsetNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemsetNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphMemsetNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphMemsetNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeFindInClone(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeFindInClone — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeGetDependencies(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeGetDependencies — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeGetDependentNodes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeGetDependentNodes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeGetEnabled(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeGetEnabled — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeGetType(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeGetType — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeSetEnabled(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeSetEnabled — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphReleaseUserObject(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphReleaseUserObject — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphRemoveDependencies(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphRemoveDependencies — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphRetainUserObject(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphRetainUserObject — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphUpload(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphUpload — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphicsGLRegisterBuffer(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphicsGLRegisterBuffer — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphicsGLRegisterImage(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphicsGLRegisterImage — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphicsMapResources(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphicsMapResources*>(payload);
  hipGraphicsResource_t _out_resources{};
  hipError_t _r = (hipError_t)hipGraphicsMapResources((int)a->count, &_out_resources, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipGraphicsResourceGetMappedPointer(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphicsResourceGetMappedPointer*>(payload);
  void* _out_devPtr = nullptr;
  size_t _out_size{};
  hipError_t _r = (hipError_t)hipGraphicsResourceGetMappedPointer((void**)&_out_devPtr, &_out_size, (hipGraphicsResource_t)a->resource);
  return _r;
}

static hipError_t playback_hipGraphicsSubResourceGetMappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphicsSubResourceGetMappedArray*>(payload);
  hipArray_t _out_array = nullptr;
  hipError_t _r = (hipError_t)hipGraphicsSubResourceGetMappedArray(&_out_array, (hipGraphicsResource_t)a->resource, (unsigned int)a->arrayIndex, (unsigned int)a->mipLevel);
  return _r;
}

static hipError_t playback_hipGraphicsUnmapResources(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphicsUnmapResources*>(payload);
  hipGraphicsResource_t _out_resources{};
  hipError_t _r = (hipError_t)hipGraphicsUnmapResources((int)a->count, &_out_resources, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipGraphicsUnregisterResource(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphicsUnregisterResource*>(payload);
  hipError_t _r = (hipError_t)hipGraphicsUnregisterResource((hipGraphicsResource_t)a->resource);
  return _r;
}

static hipError_t playback_hipHostAlloc(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipHostAlloc — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipHostFree(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipHostFree*>(payload);
  uint64_t _rec_ptr = a->ptr;
  void*    _live_ptr = ctx.translate_ptr(_rec_ptr);
  hipError_t _r = (hipError_t)hipHostFree(_live_ptr);
  if (_r == hipSuccess) {
    ctx.remove_alloc(_rec_ptr);
  }
  return _r;
}

extern hipError_t playback_hipHostGetDevicePointer(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipHostGetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipHostGetFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipHostMalloc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipHostMalloc*>(payload);
  void* _out_ptr = nullptr;
  hipError_t _r = (hipError_t)hipHostMalloc((void**)&_out_ptr, (size_t)a->size, (unsigned int)a->flags);
  if (_r == hipSuccess) {
    ctx.record_alloc(a->ptr, _out_ptr, static_cast<size_t>(a->size));
  }
  return _r;
}

extern hipError_t playback_hipHostRegister(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipHostUnregister(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipImportExternalMemory(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipImportExternalMemory*>(payload);
  hipExternalMemory_t _out_extMem_out{};
  hipError_t _r = (hipError_t)hipImportExternalMemory(&_out_extMem_out, (const hipExternalMemoryHandleDesc*)a->memHandleDesc);
  return _r;
}

static hipError_t playback_hipImportExternalSemaphore(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipImportExternalSemaphore*>(payload);
  hipExternalSemaphore_t _out_extSem_out{};
  hipError_t _r = (hipError_t)hipImportExternalSemaphore(&_out_extSem_out, (const hipExternalSemaphoreHandleDesc*)a->semHandleDesc);
  return _r;
}

static hipError_t playback_hipInit(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipInit*>(payload);
  hipError_t _r = (hipError_t)hipInit((unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipIpcCloseMemHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipIpcCloseMemHandle*>(payload);
  hipError_t _r = (hipError_t)hipIpcCloseMemHandle(ctx.translate_ptr(a->devPtr));
  return _r;
}

static hipError_t playback_hipIpcGetEventHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipIpcGetEventHandle*>(payload);
  hipIpcEventHandle_t* _s_handle{};
  hipError_t _r = (hipError_t)hipIpcGetEventHandle(_s_handle, (hipEvent_t)ctx.translate_event(a->event));
  return _r;
}

static hipError_t playback_hipIpcGetMemHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipIpcGetMemHandle*>(payload);
  hipIpcMemHandle_t* _s_handle{};
  hipError_t _r = (hipError_t)hipIpcGetMemHandle(_s_handle, ctx.translate_ptr(a->devPtr));
  return _r;
}

static hipError_t playback_hipIpcOpenEventHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipIpcOpenEventHandle*>(payload);
  hipEvent_t _out_event = nullptr;
  hipIpcEventHandle_t _s_handle{};
  hipError_t _r = (hipError_t)hipIpcOpenEventHandle(&_out_event, _s_handle);
  return _r;
}

static hipError_t playback_hipIpcOpenMemHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipIpcOpenMemHandle*>(payload);
  void* _out_devPtr = nullptr;
  hipIpcMemHandle_t _s_handle{};
  hipError_t _r = (hipError_t)hipIpcOpenMemHandle((void**)&_out_devPtr, _s_handle, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipKernelNameRef(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelNameRef — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipKernelNameRefByPtr(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelNameRefByPtr — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipLaunchByPtr(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipLaunchCooperativeKernel(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLaunchCooperativeKernel — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLaunchCooperativeKernelMultiDevice(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLaunchCooperativeKernelMultiDevice*>(payload);
  hipLaunchParams _out_launchParamsList{};
  hipError_t _r = (hipError_t)hipLaunchCooperativeKernelMultiDevice(&_out_launchParamsList, (int)a->numDevices, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipLaunchHostFunc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLaunchHostFunc*>(payload);
  hipError_t _r = (hipError_t)hipLaunchHostFunc((hipStream_t)ctx.translate_stream(a->stream), (hipHostFn_t)a->fn, (void*)a->userData);
  return _r;
}

extern hipError_t playback_hipLaunchKernel(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMalloc(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMalloc3D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMalloc3D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMalloc3DArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMalloc3DArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMallocArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMallocArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMallocAsync(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMallocFromPoolAsync(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMallocHost(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMallocHost — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMallocManaged(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMallocMipmappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMallocMipmappedArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMallocPitch(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMallocPitch*>(payload);
  void* _out_ptr = nullptr;
  size_t _out_pitch{};
  hipError_t _r = (hipError_t)hipMallocPitch((void**)&_out_ptr, &_out_pitch, (size_t)a->width, (size_t)a->height);
  if (_r == hipSuccess) {
    ctx.record_alloc(a->ptr, _out_ptr, static_cast<size_t>(a->width));
  }
  return _r;
}

extern hipError_t playback_hipMemAddressFree(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemAddressReserve(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemAdvise(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemAdvise*>(payload);
  hipError_t _r = (hipError_t)hipMemAdvise(ctx.translate_ptr(a->dev_ptr), (size_t)a->count, (hipMemoryAdvise)a->advice, (int)a->device);
  return _r;
}

static hipError_t playback_hipMemAdvise_v2(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemAdvise_v2*>(payload);
  hipMemLocation _s_device{};
  hipError_t _r = (hipError_t)hipMemAdvise_v2(ctx.translate_ptr(a->dev_ptr), (size_t)a->count, (hipMemoryAdvise)a->advice, _s_device);
  return _r;
}

static hipError_t playback_hipMemAllocHost(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemAllocHost — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemAllocPitch(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemAllocPitch — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemCreate(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemExportToShareableHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemExportToShareableHandle*>(payload);
  hipError_t _r = (hipError_t)hipMemExportToShareableHandle((void*)a->shareableHandle, (hipMemGenericAllocationHandle_t)a->handle, (hipMemAllocationHandleType)a->handleType, (unsigned long long)a->flags);
  return _r;
}

static hipError_t playback_hipMemGetAccess(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemGetAccess — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemGetAddressRange(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemGetAddressRange — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemGetAllocationGranularity(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemGetAllocationPropertiesFromHandle(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemGetAllocationPropertiesFromHandle — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemGetInfo(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemGetInfo*>(payload);
  size_t _out_free{};
  size_t _out_total{};
  hipError_t _r = (hipError_t)hipMemGetInfo(&_out_free, &_out_total);
  return _r;
}

static hipError_t playback_hipMemImportFromShareableHandle(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemImportFromShareableHandle — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemMap(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemMapArrayAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemMapArrayAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemPoolCreate(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemPoolDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPoolDestroy*>(payload);
  uint64_t _rec_hdl = a->mem_pool;
  hipError_t _r = (hipError_t)hipMemPoolDestroy((hipMemPool_t)ctx.translate_mempool(_rec_hdl));
  if (_r == hipSuccess) {
    ctx.remove_mempool(_rec_hdl);
  }
  return _r;
}

static hipError_t playback_hipMemPoolExportPointer(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemPoolExportPointer — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemPoolExportToShareableHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPoolExportToShareableHandle*>(payload);
  hipError_t _r = (hipError_t)hipMemPoolExportToShareableHandle((void*)a->shared_handle, (hipMemPool_t)ctx.translate_mempool(a->mem_pool), (hipMemAllocationHandleType)a->handle_type, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipMemPoolGetAccess(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemPoolGetAccess — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemPoolGetAttribute(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemPoolImportFromShareableHandle(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPoolImportFromShareableHandle*>(payload);
  hipMemPool_t _out_mem_pool = nullptr;
  hipError_t _r = (hipError_t)hipMemPoolImportFromShareableHandle(&_out_mem_pool, (void*)a->shared_handle, (hipMemAllocationHandleType)a->handle_type, (unsigned int)a->flags);
  if (_r == hipSuccess) {
    ctx.record_mempool(a->mem_pool, _out_mem_pool);
  }
  return _r;
}

static hipError_t playback_hipMemPoolImportPointer(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemPoolImportPointer — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemPoolSetAccess(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemPoolSetAttribute(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemPoolTrimTo(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPoolTrimTo*>(payload);
  hipError_t _r = (hipError_t)hipMemPoolTrimTo((hipMemPool_t)ctx.translate_mempool(a->mem_pool), (size_t)a->min_bytes_to_hold);
  return _r;
}

static hipError_t playback_hipMemPrefetchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPrefetchAsync*>(payload);
  hipError_t _r = (hipError_t)hipMemPrefetchAsync(ctx.translate_ptr(a->dev_ptr), (size_t)a->count, (int)a->device, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemPrefetchAsync_v2(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPrefetchAsync_v2*>(payload);
  hipMemLocation _s_location{};
  hipError_t _r = (hipError_t)hipMemPrefetchAsync_v2(ctx.translate_ptr(a->dev_ptr), (size_t)a->count, _s_location, (unsigned int)a->flags, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemPrefetchBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemPrefetchBatchAsync*>(payload);
  void* _out_dev_ptrs = nullptr;
  size_t _out_sizes{};
  hipMemLocation* _s_prefetch_locs{};
  size_t _out_prefetch_loc_idxs{};
  hipError_t _r = (hipError_t)hipMemPrefetchBatchAsync((void**)&_out_dev_ptrs, &_out_sizes, (size_t)a->count, _s_prefetch_locs, &_out_prefetch_loc_idxs, (size_t)a->num_prefetch_locs, (unsigned long long)a->flags, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemDiscardBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemDiscardBatchAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvMemDiscardBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvMemDiscardBatchAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemDiscardAndPrefetchBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemDiscardAndPrefetchBatchAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvMemDiscardAndPrefetchBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvMemDiscardAndPrefetchBatchAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemPtrGetInfo(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemPtrGetInfo — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemRangeGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemRangeGetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemRangeGetAttributes(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemRangeGetAttributes — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemRelease(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemRetainAllocationHandle(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemRetainAllocationHandle — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemSetAccess(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemUnmap(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemcpy(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemcpy2D(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpy2D*>(payload);
  hipError_t _r = (hipError_t)hipMemcpy2D(ctx.translate_ptr(a->dst), (size_t)a->dpitch, ctx.translate_ptr(a->src), (size_t)a->spitch, (size_t)a->width, (size_t)a->height, (hipMemcpyKind)a->kind);
  return _r;
}

static hipError_t playback_hipMemcpy2DAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpy2DAsync*>(payload);
  hipError_t _r = (hipError_t)hipMemcpy2DAsync(ctx.translate_ptr(a->dst), (size_t)a->dpitch, ctx.translate_ptr(a->src), (size_t)a->spitch, (size_t)a->width, (size_t)a->height, (hipMemcpyKind)a->kind, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemcpy2DFromArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DFromArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DFromArrayAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DFromArrayAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DToArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DToArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DToArrayAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DToArrayAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemcpy3D(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemcpy3DAsync(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemcpyAsync(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemcpyAtoH(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyAtoH — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyDtoD(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpyDtoD*>(payload);
  hipError_t _r = (hipError_t)hipMemcpyDtoD((hipDeviceptr_t)ctx.translate_ptr(a->dst), (hipDeviceptr_t)ctx.translate_ptr(a->src), (size_t)a->sizeBytes);
  return _r;
}

static hipError_t playback_hipMemcpyDtoDAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpyDtoDAsync*>(payload);
  hipError_t _r = (hipError_t)hipMemcpyDtoDAsync((hipDeviceptr_t)ctx.translate_ptr(a->dst), (hipDeviceptr_t)ctx.translate_ptr(a->src), (size_t)a->sizeBytes, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

extern hipError_t playback_hipMemcpyDtoH(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemcpyDtoHAsync(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemcpyFromArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyFromArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyFromSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyFromSymbol — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyFromSymbolAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyFromSymbolAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyHtoA(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyHtoA — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemcpyHtoD(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipMemcpyHtoDAsync(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemcpyParam2D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyParam2D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyParam2DAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyParam2DAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyPeer(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpyPeer*>(payload);
  hipError_t _r = (hipError_t)hipMemcpyPeer(ctx.translate_ptr(a->dst), (int)a->dstDeviceId, ctx.translate_ptr(a->src), (int)a->srcDeviceId, (size_t)a->sizeBytes);
  return _r;
}

static hipError_t playback_hipMemcpyPeerAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpyPeerAsync*>(payload);
  hipError_t _r = (hipError_t)hipMemcpyPeerAsync(ctx.translate_ptr(a->dst), (int)a->dstDeviceId, ctx.translate_ptr(a->src), (int)a->srcDevice, (size_t)a->sizeBytes, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemcpyToArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyToArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyToSymbol(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyToSymbol — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyToSymbolAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyToSymbolAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemcpyWithStream(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemset(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemset*>(payload);
  hipError_t _r = (hipError_t)hipMemset(ctx.translate_ptr(a->dst), (int)a->value, (size_t)a->sizeBytes);
  return _r;
}

static hipError_t playback_hipMemset2D(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemset2D*>(payload);
  hipError_t _r = (hipError_t)hipMemset2D(ctx.translate_ptr(a->dst), (size_t)a->pitch, (int)a->value, (size_t)a->width, (size_t)a->height);
  return _r;
}

static hipError_t playback_hipMemset2DAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemset2DAsync*>(payload);
  hipError_t _r = (hipError_t)hipMemset2DAsync(ctx.translate_ptr(a->dst), (size_t)a->pitch, (int)a->value, (size_t)a->width, (size_t)a->height, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemset3D(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset3D — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemset3DAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset3DAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetAsync*>(payload);
  hipError_t _r = (hipError_t)hipMemsetAsync(ctx.translate_ptr(a->dst), (int)a->value, (size_t)a->sizeBytes, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemsetD16(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetD16*>(payload);
  hipError_t _r = (hipError_t)hipMemsetD16((hipDeviceptr_t)ctx.translate_ptr(a->dest), (unsigned short)a->value, (size_t)a->count);
  return _r;
}

static hipError_t playback_hipMemsetD16Async(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetD16Async*>(payload);
  hipError_t _r = (hipError_t)hipMemsetD16Async((hipDeviceptr_t)ctx.translate_ptr(a->dest), (unsigned short)a->value, (size_t)a->count, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemsetD32(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetD32*>(payload);
  hipError_t _r = (hipError_t)hipMemsetD32((hipDeviceptr_t)ctx.translate_ptr(a->dest), (int)a->value, (size_t)a->count);
  return _r;
}

static hipError_t playback_hipMemsetD32Async(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetD32Async*>(payload);
  hipError_t _r = (hipError_t)hipMemsetD32Async((hipDeviceptr_t)ctx.translate_ptr(a->dst), (int)a->value, (size_t)a->count, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemsetD8(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetD8*>(payload);
  hipError_t _r = (hipError_t)hipMemsetD8((hipDeviceptr_t)ctx.translate_ptr(a->dest), (unsigned char)a->value, (size_t)a->count);
  return _r;
}

static hipError_t playback_hipMemsetD8Async(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemsetD8Async*>(payload);
  hipError_t _r = (hipError_t)hipMemsetD8Async((hipDeviceptr_t)ctx.translate_ptr(a->dest), (unsigned char)a->value, (size_t)a->count, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMipmappedArrayCreate(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMipmappedArrayCreate — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMipmappedArrayDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMipmappedArrayDestroy — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMipmappedArrayGetLevel(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMipmappedArrayGetLevel — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipModuleGetFunction(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipModuleGetFunctionCount(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleGetFunctionCount — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleGetGlobal(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleGetGlobal — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleGetTexRef(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleGetTexRef — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleLaunchCooperativeKernel(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipModuleLaunchCooperativeKernel*>(payload);
  void* _out_kernelParams = nullptr;
  hipError_t _r = (hipError_t)hipModuleLaunchCooperativeKernel((hipFunction_t)ctx.translate_func(a->f), (unsigned int)a->gridDimX, (unsigned int)a->gridDimY, (unsigned int)a->gridDimZ, (unsigned int)a->blockDimX, (unsigned int)a->blockDimY, (unsigned int)a->blockDimZ, (unsigned int)a->sharedMemBytes, (hipStream_t)ctx.translate_stream(a->stream), (void**)&_out_kernelParams);
  return _r;
}

static hipError_t playback_hipModuleLaunchCooperativeKernelMultiDevice(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipModuleLaunchCooperativeKernelMultiDevice*>(payload);
  hipFunctionLaunchParams _out_launchParamsList{};
  hipError_t _r = (hipError_t)hipModuleLaunchCooperativeKernelMultiDevice(&_out_launchParamsList, (unsigned int)a->numDevices, (unsigned int)a->flags);
  return _r;
}

extern hipError_t playback_hipModuleLaunchKernel(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipModuleLoad(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipModuleLoadData(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipModuleLoadDataEx(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipLinkAddData(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLinkAddData*>(payload);
  hipJitOption _out_options{};
  void* _out_optionValues = nullptr;
  hipError_t _r = (hipError_t)hipLinkAddData((hipLinkState_t)a->state, (hipJitInputType)a->type, (void*)a->data, (size_t)a->size, (const char*)a->name, (unsigned int)a->numOptions, &_out_options, (void**)&_out_optionValues);
  return _r;
}

static hipError_t playback_hipLinkAddFile(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLinkAddFile*>(payload);
  hipJitOption _out_options{};
  void* _out_optionValues = nullptr;
  hipError_t _r = (hipError_t)hipLinkAddFile((hipLinkState_t)a->state, (hipJitInputType)a->type, (const char*)a->path, (unsigned int)a->numOptions, &_out_options, (void**)&_out_optionValues);
  return _r;
}

static hipError_t playback_hipLinkComplete(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLinkComplete*>(payload);
  void* _out_hipBinOut = nullptr;
  size_t _out_sizeOut{};
  hipError_t _r = (hipError_t)hipLinkComplete((hipLinkState_t)a->state, (void**)&_out_hipBinOut, &_out_sizeOut);
  return _r;
}

static hipError_t playback_hipLinkCreate(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLinkCreate*>(payload);
  hipJitOption _out_options{};
  void* _out_optionValues = nullptr;
  hipLinkState_t _out_stateOut{};
  hipError_t _r = (hipError_t)hipLinkCreate((unsigned int)a->numOptions, &_out_options, (void**)&_out_optionValues, &_out_stateOut);
  return _r;
}

static hipError_t playback_hipLinkDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLinkDestroy*>(payload);
  hipError_t _r = (hipError_t)hipLinkDestroy((hipLinkState_t)a->state);
  return _r;
}

static hipError_t playback_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleOccupancyMaxActiveBlocksPerMultiprocessor — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleOccupancyMaxPotentialBlockSize(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleOccupancyMaxPotentialBlockSize — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleOccupancyMaxPotentialBlockSizeWithFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleOccupancyMaxPotentialBlockSizeWithFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipModuleUnload(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleUnload — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipOccupancyAvailableDynamicSMemPerBlock(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipOccupancyAvailableDynamicSMemPerBlock — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipOccupancyMaxActiveBlocksPerMultiprocessor(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipOccupancyMaxActiveBlocksPerMultiprocessor — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipOccupancyMaxPotentialBlockSize(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipOccupancyMaxPotentialBlockSize — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipOccupancyMaxActiveClusters(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipOccupancyMaxActiveClusters — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipOccupancyMaxPotentialClusterSize(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipOccupancyMaxPotentialClusterSize — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipPeekAtLastError(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipPeekAtLastError*>(payload);
  hipError_t _r = (hipError_t)hipPeekAtLastError();
  return _r;
}

static hipError_t playback_hipPointerGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipPointerGetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipPointerGetAttributes(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipPointerGetAttributes*>(payload);
  hipPointerAttribute_t _out_attributes{};
  hipError_t _r = (hipError_t)hipPointerGetAttributes(&_out_attributes, ctx.translate_ptr(a->ptr));
  return _r;
}

static hipError_t playback_hipPointerSetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipPointerSetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipProfilerStart(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipProfilerStart*>(payload);
  hipError_t _r = (hipError_t)hipProfilerStart();
  return _r;
}

static hipError_t playback_hipProfilerStop(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipProfilerStop*>(payload);
  hipError_t _r = (hipError_t)hipProfilerStop();
  return _r;
}

static hipError_t playback_hipRuntimeGetVersion(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipRuntimeGetVersion*>(payload);
  int _out_runtimeVersion{};
  hipError_t _r = (hipError_t)hipRuntimeGetVersion(&_out_runtimeVersion);
  return _r;
}

static hipError_t playback_hipSetDevice(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipSetDevice*>(payload);
  hipError_t _r = (hipError_t)hipSetDevice((int)a->deviceId);
  return _r;
}

static hipError_t playback_hipSetDeviceFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipSetDeviceFlags*>(payload);
  hipError_t _r = (hipError_t)hipSetDeviceFlags((unsigned)a->flags);
  return _r;
}

static hipError_t playback_hipSetupArgument(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipSetupArgument*>(payload);
  hipError_t _r = (hipError_t)hipSetupArgument((const void*)a->arg, (size_t)a->size, (size_t)a->offset);
  return _r;
}

static hipError_t playback_hipSignalExternalSemaphoresAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipSignalExternalSemaphoresAsync*>(payload);
  hipError_t _r = (hipError_t)hipSignalExternalSemaphoresAsync((const hipExternalSemaphore_t*)a->extSemArray, (const hipExternalSemaphoreSignalParams*)a->paramsArray, (unsigned int)a->numExtSems, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipStreamAddCallback(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamAddCallback*>(payload);
  hipError_t _r = (hipError_t)hipStreamAddCallback((hipStream_t)ctx.translate_stream(a->stream), (hipStreamCallback_t)a->callback, (void*)a->userData, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipStreamAttachMemAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamAttachMemAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipStreamBeginCapture(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipStreamCopyAttributes(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamCopyAttributes*>(payload);
  hipError_t _r = (hipError_t)hipStreamCopyAttributes((hipStream_t)ctx.translate_stream(a->dst), (hipStream_t)ctx.translate_stream(a->src));
  return _r;
}

extern hipError_t playback_hipStreamCreate(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipStreamCreateWithFlags(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipStreamCreateWithPriority(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipStreamDestroy(PlaybackContext& ctx, const uint8_t* payload);

extern hipError_t playback_hipStreamEndCapture(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipStreamGetCaptureInfo(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetCaptureInfo*>(payload);
  hipStreamCaptureStatus _out_pCaptureStatus{};
  unsigned long long _out_pId{};
  hipError_t _r = (hipError_t)hipStreamGetCaptureInfo((hipStream_t)ctx.translate_stream(a->stream), &_out_pCaptureStatus, &_out_pId);
  return _r;
}

static hipError_t playback_hipStreamGetCaptureInfo_v2(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamGetCaptureInfo_v2 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamGetDevice(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamGetDevice — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamGetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetFlags*>(payload);
  unsigned int _out_flags{};
  hipError_t _r = (hipError_t)hipStreamGetFlags((hipStream_t)ctx.translate_stream(a->stream), &_out_flags);
  return _r;
}

static hipError_t playback_hipStreamGetId(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetId*>(payload);
  unsigned long long _out_streamId{};
  hipError_t _r = (hipError_t)hipStreamGetId((hipStream_t)ctx.translate_stream(a->stream), &_out_streamId);
  return _r;
}

static hipError_t playback_hipStreamGetPriority(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetPriority*>(payload);
  int _out_priority{};
  hipError_t _r = (hipError_t)hipStreamGetPriority((hipStream_t)ctx.translate_stream(a->stream), &_out_priority);
  return _r;
}

static hipError_t playback_hipStreamIsCapturing(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamIsCapturing*>(payload);
  hipStreamCaptureStatus _out_pCaptureStatus{};
  hipError_t _r = (hipError_t)hipStreamIsCapturing((hipStream_t)ctx.translate_stream(a->stream), &_out_pCaptureStatus);
  return _r;
}

static hipError_t playback_hipStreamQuery(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamQuery*>(payload);
  hipError_t _r = (hipError_t)hipStreamQuery((hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipStreamSynchronize(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamSynchronize*>(payload);
  hipError_t _r = (hipError_t)hipStreamSynchronize((hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipStreamUpdateCaptureDependencies(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamUpdateCaptureDependencies — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamWaitEvent(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamWaitEvent*>(payload);
  hipError_t _r = (hipError_t)hipStreamWaitEvent((hipStream_t)ctx.translate_stream(a->stream), (hipEvent_t)ctx.translate_event(a->event), (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipStreamWaitValue32(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamWaitValue32 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamWaitValue64(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamWaitValue64 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamWriteValue32(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamWriteValue32 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamWriteValue64(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamWriteValue64 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamBatchMemOp(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamBatchMemOp*>(payload);
  hipStreamBatchMemOpParams _out_paramArray{};
  hipError_t _r = (hipError_t)hipStreamBatchMemOp((hipStream_t)ctx.translate_stream(a->stream), (unsigned int)a->count, &_out_paramArray, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipTexObjectCreate(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipTexObjectCreate — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipTexObjectDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipTexObjectDestroy — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipTexObjectGetResourceDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexObjectGetResourceDesc*>(payload);
  HIP_RESOURCE_DESC _out_pResDesc{};
  hipError_t _r = (hipError_t)hipTexObjectGetResourceDesc(&_out_pResDesc, (hipTextureObject_t)ctx.translate_texture(a->texObject));
  return _r;
}

static hipError_t playback_hipTexObjectGetResourceViewDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexObjectGetResourceViewDesc*>(payload);
  HIP_RESOURCE_VIEW_DESC _out_pResViewDesc{};
  hipError_t _r = (hipError_t)hipTexObjectGetResourceViewDesc(&_out_pResViewDesc, (hipTextureObject_t)ctx.translate_texture(a->texObject));
  return _r;
}

static hipError_t playback_hipTexObjectGetTextureDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexObjectGetTextureDesc*>(payload);
  HIP_TEXTURE_DESC _out_pTexDesc{};
  hipError_t _r = (hipError_t)hipTexObjectGetTextureDesc(&_out_pTexDesc, (hipTextureObject_t)ctx.translate_texture(a->texObject));
  return _r;
}

static hipError_t playback_hipTexRefGetAddress(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipTexRefGetAddress — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipTexRefGetAddressMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetAddressMode*>(payload);
  enum hipTextureAddressMode _out_pam{};
  hipError_t _r = (hipError_t)hipTexRefGetAddressMode(&_out_pam, (const textureReference*)a->texRef, (int)a->dim);
  return _r;
}

static hipError_t playback_hipTexRefGetFilterMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetFilterMode*>(payload);
  enum hipTextureFilterMode _out_pfm{};
  hipError_t _r = (hipError_t)hipTexRefGetFilterMode(&_out_pfm, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetFlags*>(payload);
  unsigned int _out_pFlags{};
  hipError_t _r = (hipError_t)hipTexRefGetFlags(&_out_pFlags, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetFormat(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipTexRefGetFormat — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipTexRefGetMaxAnisotropy(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetMaxAnisotropy*>(payload);
  int _out_pmaxAnsio{};
  hipError_t _r = (hipError_t)hipTexRefGetMaxAnisotropy(&_out_pmaxAnsio, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetMipMappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetMipMappedArray*>(payload);
  hipMipmappedArray_t _out_pArray = nullptr;
  hipError_t _r = (hipError_t)hipTexRefGetMipMappedArray(&_out_pArray, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetMipmapFilterMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetMipmapFilterMode*>(payload);
  enum hipTextureFilterMode _out_pfm{};
  hipError_t _r = (hipError_t)hipTexRefGetMipmapFilterMode(&_out_pfm, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetMipmapLevelBias(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetMipmapLevelBias*>(payload);
  float _out_pbias{};
  hipError_t _r = (hipError_t)hipTexRefGetMipmapLevelBias(&_out_pbias, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetMipmapLevelClamp(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetMipmapLevelClamp*>(payload);
  float _out_pminMipmapLevelClamp{};
  float _out_pmaxMipmapLevelClamp{};
  hipError_t _r = (hipError_t)hipTexRefGetMipmapLevelClamp(&_out_pminMipmapLevelClamp, &_out_pmaxMipmapLevelClamp, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefSetAddress(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetAddress*>(payload);
  size_t _out_ByteOffset{};
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetAddress(&_out_ByteOffset, &_out_texRef, (hipDeviceptr_t)ctx.translate_ptr(a->dptr), (size_t)a->bytes);
  return _r;
}

static hipError_t playback_hipTexRefSetAddress2D(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetAddress2D*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetAddress2D(&_out_texRef, (const HIP_ARRAY_DESCRIPTOR*)a->desc, (hipDeviceptr_t)ctx.translate_ptr(a->dptr), (size_t)a->Pitch);
  return _r;
}

static hipError_t playback_hipTexRefSetAddressMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetAddressMode*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetAddressMode(&_out_texRef, (int)a->dim, (enum hipTextureAddressMode)a->am);
  return _r;
}

static hipError_t playback_hipTexRefSetArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetArray*>(payload);
  textureReference _out_tex{};
  hipError_t _r = (hipError_t)hipTexRefSetArray(&_out_tex, (hipArray_t)ctx.translate_array(a->array), (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipTexRefSetBorderColor(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetBorderColor*>(payload);
  textureReference _out_texRef{};
  float _out_pBorderColor{};
  hipError_t _r = (hipError_t)hipTexRefSetBorderColor(&_out_texRef, &_out_pBorderColor);
  return _r;
}

static hipError_t playback_hipTexRefSetFilterMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetFilterMode*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetFilterMode(&_out_texRef, (enum hipTextureFilterMode)a->fm);
  return _r;
}

static hipError_t playback_hipTexRefSetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetFlags*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetFlags(&_out_texRef, (unsigned int)a->Flags);
  return _r;
}

static hipError_t playback_hipTexRefSetFormat(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipTexRefSetFormat — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipTexRefSetMaxAnisotropy(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetMaxAnisotropy*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetMaxAnisotropy(&_out_texRef, (unsigned int)a->maxAniso);
  return _r;
}

static hipError_t playback_hipTexRefSetMipmapFilterMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetMipmapFilterMode*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetMipmapFilterMode(&_out_texRef, (enum hipTextureFilterMode)a->fm);
  return _r;
}

static hipError_t playback_hipTexRefSetMipmapLevelBias(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetMipmapLevelBias*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetMipmapLevelBias(&_out_texRef, (float)a->bias);
  return _r;
}

static hipError_t playback_hipTexRefSetMipmapLevelClamp(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetMipmapLevelClamp*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetMipmapLevelClamp(&_out_texRef, (float)a->minMipMapLevelClamp, (float)a->maxMipMapLevelClamp);
  return _r;
}

static hipError_t playback_hipTexRefSetMipmappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefSetMipmappedArray*>(payload);
  textureReference _out_texRef{};
  hipError_t _r = (hipError_t)hipTexRefSetMipmappedArray(&_out_texRef, (hipMipmappedArray_t)ctx.translate_mipmapped(a->mipmappedArray), (unsigned int)a->Flags);
  return _r;
}

static hipError_t playback_hipThreadExchangeStreamCaptureMode(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipThreadExchangeStreamCaptureMode*>(payload);
  hipStreamCaptureMode _out_mode{};
  hipError_t _r = (hipError_t)hipThreadExchangeStreamCaptureMode(&_out_mode);
  return _r;
}

static hipError_t playback_hipUnbindTexture(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipUnbindTexture*>(payload);
  hipError_t _r = (hipError_t)hipUnbindTexture((const textureReference*)a->tex);
  return _r;
}

static hipError_t playback_hipUserObjectCreate(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipUserObjectCreate — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipUserObjectRelease(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipUserObjectRelease — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipUserObjectRetain(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipUserObjectRetain — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipWaitExternalSemaphoresAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipWaitExternalSemaphoresAsync*>(payload);
  hipError_t _r = (hipError_t)hipWaitExternalSemaphoresAsync((const hipExternalSemaphore_t*)a->extSemArray, (const hipExternalSemaphoreWaitParams*)a->paramsArray, (unsigned int)a->numExtSems, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemcpy_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyToSymbol_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyToSymbol_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyFromSymbol_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyFromSymbol_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2D_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2D_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DFromArray_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DFromArray_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemcpy3D_spt(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemset_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemset2D_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset2D_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemset2DAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset2DAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemset3DAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset3DAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemset3D_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemset3D_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipMemcpy3DAsync_spt(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipMemcpy2DAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyFromSymbolAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyFromSymbolAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyToSymbolAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyToSymbolAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyFromArray_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyFromArray_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DToArray_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DToArray_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DFromArrayAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DFromArrayAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DToArrayAsync_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DToArrayAsync_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamQuery_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamQuery_spt*>(payload);
  hipError_t _r = (hipError_t)hipStreamQuery_spt((hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipStreamSynchronize_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamSynchronize_spt*>(payload);
  hipError_t _r = (hipError_t)hipStreamSynchronize_spt((hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipStreamGetPriority_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetPriority_spt*>(payload);
  int _out_priority{};
  hipError_t _r = (hipError_t)hipStreamGetPriority_spt((hipStream_t)ctx.translate_stream(a->stream), &_out_priority);
  return _r;
}

static hipError_t playback_hipStreamWaitEvent_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamWaitEvent_spt*>(payload);
  hipError_t _r = (hipError_t)hipStreamWaitEvent_spt((hipStream_t)ctx.translate_stream(a->stream), (hipEvent_t)ctx.translate_event(a->event), (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipStreamGetFlags_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetFlags_spt*>(payload);
  unsigned int _out_flags{};
  hipError_t _r = (hipError_t)hipStreamGetFlags_spt((hipStream_t)ctx.translate_stream(a->stream), &_out_flags);
  return _r;
}

static hipError_t playback_hipStreamAddCallback_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamAddCallback_spt*>(payload);
  hipError_t _r = (hipError_t)hipStreamAddCallback_spt((hipStream_t)ctx.translate_stream(a->stream), (hipStreamCallback_t)a->callback, (void*)a->userData, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipEventRecord_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipEventRecord_spt*>(payload);
  hipError_t _r = (hipError_t)hipEventRecord_spt((hipEvent_t)ctx.translate_event(a->event), (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipLaunchCooperativeKernel_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLaunchCooperativeKernel_spt*>(payload);
  dim3 _dim_gridDim(a->gridDim_x, a->gridDim_y, a->gridDim_z);
  dim3 _dim_blockDim(a->blockDim_x, a->blockDim_y, a->blockDim_z);
  void* _out_kernelParams = nullptr;
  hipError_t _r = (hipError_t)hipLaunchCooperativeKernel_spt((const void*)a->f, _dim_gridDim, _dim_blockDim, (void**)&_out_kernelParams, (uint32_t)a->sharedMemBytes, (hipStream_t)ctx.translate_stream(a->hStream));
  return _r;
}

static hipError_t playback_hipLaunchKernel_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLaunchKernel_spt*>(payload);
  dim3 _dim_numBlocks(a->numBlocks_x, a->numBlocks_y, a->numBlocks_z);
  dim3 _dim_dimBlocks(a->dimBlocks_x, a->dimBlocks_y, a->dimBlocks_z);
  void* _out_args = nullptr;
  hipError_t _r = (hipError_t)hipLaunchKernel_spt((const void*)a->function_address, _dim_numBlocks, _dim_dimBlocks, (void**)&_out_args, (size_t)a->sharedMemBytes, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipGraphLaunch_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphLaunch_spt*>(payload);
  hipError_t _r = (hipError_t)hipGraphLaunch_spt((hipGraphExec_t)ctx.translate_graph_exec(a->graphExec), (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipStreamBeginCapture_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamBeginCapture_spt*>(payload);
  hipError_t _r = (hipError_t)hipStreamBeginCapture_spt((hipStream_t)ctx.translate_stream(a->stream), (hipStreamCaptureMode)a->mode);
  return _r;
}

static hipError_t playback_hipStreamEndCapture_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamEndCapture_spt*>(payload);
  hipGraph_t _out_pGraph = nullptr;
  hipError_t _r = (hipError_t)hipStreamEndCapture_spt((hipStream_t)ctx.translate_stream(a->stream), &_out_pGraph);
  return _r;
}

static hipError_t playback_hipStreamIsCapturing_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamIsCapturing_spt*>(payload);
  hipStreamCaptureStatus _out_pCaptureStatus{};
  hipError_t _r = (hipError_t)hipStreamIsCapturing_spt((hipStream_t)ctx.translate_stream(a->stream), &_out_pCaptureStatus);
  return _r;
}

static hipError_t playback_hipStreamGetCaptureInfo_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetCaptureInfo_spt*>(payload);
  hipStreamCaptureStatus _out_pCaptureStatus{};
  unsigned long long _out_pId{};
  hipError_t _r = (hipError_t)hipStreamGetCaptureInfo_spt((hipStream_t)ctx.translate_stream(a->stream), &_out_pCaptureStatus, &_out_pId);
  return _r;
}

static hipError_t playback_hipStreamGetCaptureInfo_v2_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamGetCaptureInfo_v2_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLaunchHostFunc_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLaunchHostFunc_spt*>(payload);
  hipError_t _r = (hipError_t)hipLaunchHostFunc_spt((hipStream_t)ctx.translate_stream(a->stream), (hipHostFn_t)a->fn, (void*)a->userData);
  return _r;
}

static hipError_t playback_hipCreateChannelDesc(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipCreateChannelDesc — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipExtModuleLaunchKernel(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipHccModuleLaunchKernel(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipHccModuleLaunchKernel — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetStreamDeviceId(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetStreamDeviceId — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGraphAddMemsetNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphAddMemsetNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddExternalSemaphoresWaitNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddExternalSemaphoresWaitNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddExternalSemaphoresSignalNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddExternalSemaphoresSignalNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExternalSemaphoresSignalNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExternalSemaphoresSignalNodeSetParams*>(payload);
  hipError_t _r = (hipError_t)hipGraphExternalSemaphoresSignalNodeSetParams((hipGraphNode_t)a->hNode, (const hipExternalSemaphoreSignalNodeParams*)a->nodeParams);
  return _r;
}

static hipError_t playback_hipGraphExternalSemaphoresWaitNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExternalSemaphoresWaitNodeSetParams*>(payload);
  hipError_t _r = (hipError_t)hipGraphExternalSemaphoresWaitNodeSetParams((hipGraphNode_t)a->hNode, (const hipExternalSemaphoreWaitNodeParams*)a->nodeParams);
  return _r;
}

static hipError_t playback_hipGraphExternalSemaphoresSignalNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExternalSemaphoresSignalNodeGetParams*>(payload);
  hipExternalSemaphoreSignalNodeParams _out_params_out{};
  hipError_t _r = (hipError_t)hipGraphExternalSemaphoresSignalNodeGetParams((hipGraphNode_t)a->hNode, &_out_params_out);
  return _r;
}

static hipError_t playback_hipGraphExternalSemaphoresWaitNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExternalSemaphoresWaitNodeGetParams*>(payload);
  hipExternalSemaphoreWaitNodeParams _out_params_out{};
  hipError_t _r = (hipError_t)hipGraphExternalSemaphoresWaitNodeGetParams((hipGraphNode_t)a->hNode, &_out_params_out);
  return _r;
}

static hipError_t playback_hipGraphExecExternalSemaphoresSignalNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExecExternalSemaphoresSignalNodeSetParams*>(payload);
  hipError_t _r = (hipError_t)hipGraphExecExternalSemaphoresSignalNodeSetParams((hipGraphExec_t)ctx.translate_graph_exec(a->hGraphExec), (hipGraphNode_t)a->hNode, (const hipExternalSemaphoreSignalNodeParams*)a->nodeParams);
  return _r;
}

static hipError_t playback_hipGraphExecExternalSemaphoresWaitNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGraphExecExternalSemaphoresWaitNodeSetParams*>(payload);
  hipError_t _r = (hipError_t)hipGraphExecExternalSemaphoresWaitNodeSetParams((hipGraphExec_t)ctx.translate_graph_exec(a->hGraphExec), (hipGraphNode_t)a->hNode, (const hipExternalSemaphoreWaitNodeParams*)a->nodeParams);
  return _r;
}

static hipError_t playback_hipGraphAddNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphInstantiateWithParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphInstantiateWithParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExtGetLastError(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExtGetLastError*>(payload);
  hipError_t _r = (hipError_t)hipExtGetLastError();
  return _r;
}

static hipError_t playback_hipTexRefGetBorderColor(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetBorderColor*>(payload);
  float _out_pBorderColor{};
  hipError_t _r = (hipError_t)hipTexRefGetBorderColor(&_out_pBorderColor, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipTexRefGetArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipTexRefGetArray*>(payload);
  hipArray_t _out_pArray = nullptr;
  hipError_t _r = (hipError_t)hipTexRefGetArray(&_out_pArray, (const textureReference*)a->texRef);
  return _r;
}

static hipError_t playback_hipGetProcAddress(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetProcAddress — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipStreamBeginCaptureToGraph(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipStreamBeginCaptureToGraph — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetFuncBySymbol(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetFuncBySymbol — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGraphAddMemFreeNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphAddMemFreeNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGraphExecMemcpyNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphExecMemcpyNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGraphExecMemsetNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphExecMemsetNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipSetValidDevices(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipSetValidDevices — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyAtoD(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyAtoD — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyDtoA(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyDtoA — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyAtoA(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyAtoA — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyAtoHAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyAtoHAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyHtoAAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpyHtoAAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy2DArrayToArray(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy2DArrayToArray — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecGetFlags(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecGetFlags — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExternalMemoryGetMappedMipmappedArray(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExternalMemoryGetMappedMipmappedArray*>(payload);
  hipMipmappedArray_t _out_mipmap = nullptr;
  hipError_t _r = (hipError_t)hipExternalMemoryGetMappedMipmappedArray(&_out_mipmap, (hipExternalMemory_t)a->extMem, (const hipExternalMemoryMipmappedArrayDesc*)a->mipmapDesc);
  return _r;
}

static hipError_t playback_hipDrvGraphMemcpyNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphMemcpyNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDrvGraphMemcpyNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDrvGraphMemcpyNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipExtHostAlloc(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipExtHostAlloc — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipDeviceGetTexture1DLinearMaxWidth(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipDeviceGetTexture1DLinearMaxWidth — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphAddBatchMemOpNode(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphAddBatchMemOpNode — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphBatchMemOpNodeGetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphBatchMemOpNodeGetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphBatchMemOpNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphBatchMemOpNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGraphExecBatchMemOpNodeSetParams(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGraphExecBatchMemOpNodeSetParams — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipEventRecordWithFlags(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipEventRecordWithFlags*>(payload);
  hipError_t _r = (hipError_t)hipEventRecordWithFlags((hipEvent_t)ctx.translate_event(a->event), (hipStream_t)ctx.translate_stream(a->stream), (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipLaunchKernelExC(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLaunchKernelExC*>(payload);
  void* _out_args = nullptr;
  hipError_t _r = (hipError_t)hipLaunchKernelExC((const hipLaunchConfig_t*)a->config, ctx.translate_ptr(a->fPtr), (void**)&_out_args);
  return _r;
}

static hipError_t playback_hipDrvLaunchKernelEx(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDrvLaunchKernelEx*>(payload);
  void* _out_params = nullptr;
  void* _out_extra = nullptr;
  hipError_t _r = (hipError_t)hipDrvLaunchKernelEx((const HIP_LAUNCH_CONFIG*)a->config, (hipFunction_t)ctx.translate_func(a->f), (void**)&_out_params, (void**)&_out_extra);
  return _r;
}

static hipError_t playback_hipMemGetHandleForAddressRange(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemGetHandleForAddressRange — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetD2D8(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetD2D8 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetD2D8Async(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetD2D8Async — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetD2D16(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetD2D16 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetD2D16Async(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetD2D16Async — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetD2D32(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetD2D32 — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemsetD2D32Async(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemsetD2D32Async — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

extern hipError_t playback_hipStreamSetAttribute(PlaybackContext& ctx, const uint8_t* payload);

static hipError_t playback_hipStreamGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetAttribute*>(payload);
  hipStreamAttrValue _out_value_out{};
  hipError_t _r = (hipError_t)hipStreamGetAttribute((hipStream_t)ctx.translate_stream(a->stream), (hipStreamAttrID)a->attr, &_out_value_out);
  return _r;
}

static hipError_t playback_hipModuleLoadFatBinary(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipModuleLoadFatBinary — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpyBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpyBatchAsync*>(payload);
  void* _out_dsts = nullptr;
  void* _out_srcs = nullptr;
  size_t _out_sizes{};
  hipMemcpyAttributes _out_attrs{};
  size_t _out_attrsIdxs{};
  size_t _out_failIdx{};
  hipError_t _r = (hipError_t)hipMemcpyBatchAsync((void**)&_out_dsts, (void**)&_out_srcs, &_out_sizes, (size_t)a->count, &_out_attrs, &_out_attrsIdxs, (size_t)a->numAttrs, &_out_failIdx, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemcpy3DBatchAsync(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemcpy3DBatchAsync*>(payload);
  struct hipMemcpy3DBatchOp _out_opList{};
  size_t _out_failIdx{};
  hipError_t _r = (hipError_t)hipMemcpy3DBatchAsync((size_t)a->numOps, &_out_opList, &_out_failIdx, (unsigned long long)a->flags, (hipStream_t)ctx.translate_stream(a->stream));
  return _r;
}

static hipError_t playback_hipMemcpy3DPeer(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy3DPeer — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemcpy3DPeerAsync(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemcpy3DPeerAsync — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetDriverEntryPoint(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetDriverEntryPoint — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetDriverEntryPoint_spt(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipGetDriverEntryPoint_spt — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLibraryLoadData(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLibraryLoadData — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLibraryLoadFromFile(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLibraryLoadFromFile — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLibraryUnload(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLibraryUnload — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLibraryGetKernel(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLibraryGetKernel — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLibraryGetKernelCount(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLibraryGetKernelCount — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipLibraryGetGlobal(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLibraryGetGlobal*>(payload);
  void* _out_dptr = nullptr;
  size_t _out_bytes{};
  hipError_t _r = (hipError_t)hipLibraryGetGlobal((void**)&_out_dptr, &_out_bytes, (hipLibrary_t)a->library, (const char*)a->name);
  return _r;
}

static hipError_t playback_hipLibraryGetManaged(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipLibraryGetManaged*>(payload);
  void* _out_dptr = nullptr;
  size_t _out_bytes{};
  hipError_t _r = (hipError_t)hipLibraryGetManaged((void**)&_out_dptr, &_out_bytes, (hipLibrary_t)a->library, (const char*)a->name);
  return _r;
}

static hipError_t playback_hipLibraryEnumerateKernels(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipLibraryEnumerateKernels — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipKernelGetLibrary(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelGetLibrary — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipKernelGetName(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelGetName — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGetProcAddress_spt(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGetProcAddress_spt*>(payload);
  void* _out_pfn = nullptr;
  hipDriverProcAddressQueryResult _out_symbolStatus{};
  hipError_t _r = (hipError_t)hipGetProcAddress_spt((const char*)a->symbol, (void**)&_out_pfn, (int)a->hipVersion, (uint64_t)a->flags, &_out_symbolStatus);
  return _r;
}

static hipError_t playback_hipExtDisableLogging(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExtDisableLogging*>(payload);
  hipError_t _r = (hipError_t)hipExtDisableLogging();
  return _r;
}

static hipError_t playback_hipExtEnableLogging(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExtEnableLogging*>(payload);
  hipError_t _r = (hipError_t)hipExtEnableLogging();
  return _r;
}

static hipError_t playback_hipExtSetLoggingParams(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExtSetLoggingParams*>(payload);
  hipError_t _r = (hipError_t)hipExtSetLoggingParams((size_t)a->log_level, (size_t)a->log_size, (size_t)a->log_mask);
  return _r;
}

static hipError_t playback_hipKernelGetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelGetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipKernelSetAttribute(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelSetAttribute — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipKernelGetFunction(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelGetFunction — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipKernelGetParamInfo(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipKernelGetParamInfo — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMemSetMemPool(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipMemSetMemPool*>(payload);
  hipMemLocation* _s_location{};
  hipError_t _r = (hipError_t)hipMemSetMemPool(_s_location, (hipMemAllocationType)a->type, (hipMemPool_t)ctx.translate_mempool(a->pool));
  return _r;
}

static hipError_t playback_hipMemGetMemPool(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMemGetMemPool — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipMipmappedArrayGetMemoryRequirements(PlaybackContext& ctx, const uint8_t* payload) {
  (void)ctx; (void)payload;
  static bool warned = false;
  if (!warned) {
    warned = true;
    fprintf(stderr, "[HRR] NOOP playback handler called for hipMipmappedArrayGetMemoryRequirements — "
            "this API is not replayed; results may differ from capture.\n");
  }
  return hipSuccess;
}

static hipError_t playback_hipGreenCtxCreate(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipGreenCtxCreate*>(payload);
  hipExecutionCtx_t _out_ctx{};
  hipError_t _r = (hipError_t)hipGreenCtxCreate(&_out_ctx, (hipDevResourceDesc_t)a->desc, (int)a->device, (unsigned int)a->flags);
  return _r;
}

static hipError_t playback_hipExecutionCtxDestroy(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxDestroy*>(payload);
  hipError_t _r = (hipError_t)hipExecutionCtxDestroy((hipExecutionCtx_t)a->ctx);
  return _r;
}

static hipError_t playback_hipExecutionCtxStreamCreate(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxStreamCreate*>(payload);
  hipStream_t _out_stream = nullptr;
  hipError_t _r = (hipError_t)hipExecutionCtxStreamCreate(&_out_stream, (hipExecutionCtx_t)a->greenctx, (unsigned int)a->flags, (int)a->priority);
  return _r;
}

static hipError_t playback_hipDeviceGetDevResource(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetDevResource*>(payload);
  hipDevResource _out_resource{};
  hipError_t _r = (hipError_t)hipDeviceGetDevResource((hipDevice_t)a->device, &_out_resource, (hipDevResourceType)a->type);
  return _r;
}

static hipError_t playback_hipDevSmResourceSplitByCount(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDevSmResourceSplitByCount*>(payload);
  hipDevResource _out_result{};
  unsigned int _out_nbGroups{};
  hipDevResource _out_remainder{};
  hipError_t _r = (hipError_t)hipDevSmResourceSplitByCount(&_out_result, &_out_nbGroups, (const hipDevResource*)a->input, &_out_remainder, (unsigned int)a->flags, (unsigned int)a->minCount);
  return _r;
}

static hipError_t playback_hipDevSmResourceSplit(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDevSmResourceSplit*>(payload);
  hipDevResource _out_result{};
  hipDevResource _out_remainder{};
  hipDevSmResourceGroupParams _out_groupParams{};
  hipError_t _r = (hipError_t)hipDevSmResourceSplit(&_out_result, (unsigned int)a->nbGroups, (const hipDevResource*)a->input, &_out_remainder, (unsigned int)a->flags, &_out_groupParams);
  return _r;
}

static hipError_t playback_hipDevResourceGenerateDesc(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDevResourceGenerateDesc*>(payload);
  hipDevResourceDesc_t _out_phDesc{};
  hipDevResource _out_resources{};
  hipError_t _r = (hipError_t)hipDevResourceGenerateDesc(&_out_phDesc, &_out_resources, (unsigned int)a->nbResources);
  return _r;
}

static hipError_t playback_hipDeviceGetExecutionCtx(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipDeviceGetExecutionCtx*>(payload);
  hipExecutionCtx_t _out_ctx{};
  hipError_t _r = (hipError_t)hipDeviceGetExecutionCtx(&_out_ctx, (int)a->device);
  return _r;
}

static hipError_t playback_hipExecutionCtxGetDevResource(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxGetDevResource*>(payload);
  hipDevResource _out_resource{};
  hipError_t _r = (hipError_t)hipExecutionCtxGetDevResource((hipExecutionCtx_t)a->ctx, &_out_resource, (hipDevResourceType)a->type);
  return _r;
}

static hipError_t playback_hipExecutionCtxGetDevice(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxGetDevice*>(payload);
  int _out_device{};
  hipError_t _r = (hipError_t)hipExecutionCtxGetDevice(&_out_device, (hipExecutionCtx_t)a->ctx);
  return _r;
}

static hipError_t playback_hipExecutionCtxGetId(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxGetId*>(payload);
  unsigned long long _out_ctxId{};
  hipError_t _r = (hipError_t)hipExecutionCtxGetId((hipExecutionCtx_t)a->ctx, &_out_ctxId);
  return _r;
}

static hipError_t playback_hipStreamGetDevResource(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipStreamGetDevResource*>(payload);
  hipDevResource _out_resource{};
  hipError_t _r = (hipError_t)hipStreamGetDevResource((hipStream_t)ctx.translate_stream(a->hStream), &_out_resource, (hipDevResourceType)a->type);
  return _r;
}

static hipError_t playback_hipExecutionCtxRecordEvent(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxRecordEvent*>(payload);
  hipError_t _r = (hipError_t)hipExecutionCtxRecordEvent((hipExecutionCtx_t)a->ctx, (hipEvent_t)ctx.translate_event(a->event));
  return _r;
}

static hipError_t playback_hipExecutionCtxSynchronize(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxSynchronize*>(payload);
  hipError_t _r = (hipError_t)hipExecutionCtxSynchronize((hipExecutionCtx_t)a->ctx);
  return _r;
}

static hipError_t playback_hipExecutionCtxWaitEvent(PlaybackContext& ctx, const uint8_t* payload) {
  const auto* a = reinterpret_cast<const hrr_args_hipExecutionCtxWaitEvent*>(payload);
  hipError_t _r = (hipError_t)hipExecutionCtxWaitEvent((hipExecutionCtx_t)a->ctx, (hipEvent_t)ctx.translate_event(a->event));
  return _r;
}


// ============================================================
// Minimum payload size per event type — indexed by hrr_api_id_t
// dispatch_event() checks raw_payload.size() against this before
// calling any handler to prevent OOB casts on malformed archives.
// ============================================================
const uint32_t hrr_api_min_payload_size[HRR_API_COUNT] = {
    static_cast<uint32_t>(sizeof(hrr_args___hipPopCallConfiguration)),  // [0] HRR_API_HIPPOPCALLCONFIGURATION
    static_cast<uint32_t>(sizeof(hrr_args___hipPushCallConfiguration)),  // [1] HRR_API_HIPPUSHCALLCONFIGURATION
    static_cast<uint32_t>(sizeof(hrr_args___hipRegisterFatBinary)),  // [2] HRR_API_HIPREGISTERFATBINARY
    static_cast<uint32_t>(sizeof(hrr_args___hipRegisterFunction)),  // [3] HRR_API_HIPREGISTERFUNCTION
    static_cast<uint32_t>(sizeof(hrr_args___hipRegisterManagedVar)),  // [4] HRR_API_HIPREGISTERMANAGEDVAR
    static_cast<uint32_t>(sizeof(hrr_args___hipRegisterSurface)),  // [5] HRR_API_HIPREGISTERSURFACE
    static_cast<uint32_t>(sizeof(hrr_args___hipRegisterTexture)),  // [6] HRR_API_HIPREGISTERTEXTURE
    static_cast<uint32_t>(sizeof(hrr_args___hipRegisterVar)),  // [7] HRR_API_HIPREGISTERVAR
    static_cast<uint32_t>(sizeof(hrr_args___hipUnregisterFatBinary)),  // [8] HRR_API_HIPUNREGISTERFATBINARY
    static_cast<uint32_t>(sizeof(hrr_args_hipApiName)),  // [9] HRR_API_HIPAPINAME
    static_cast<uint32_t>(sizeof(hrr_args_hipArray3DCreate)),  // [10] HRR_API_HIPARRAY3DCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipArray3DGetDescriptor)),  // [11] HRR_API_HIPARRAY3DGETDESCRIPTOR
    static_cast<uint32_t>(sizeof(hrr_args_hipArrayCreate)),  // [12] HRR_API_HIPARRAYCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipArrayDestroy)),  // [13] HRR_API_HIPARRAYDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipArrayGetDescriptor)),  // [14] HRR_API_HIPARRAYGETDESCRIPTOR
    static_cast<uint32_t>(sizeof(hrr_args_hipArrayGetInfo)),  // [15] HRR_API_HIPARRAYGETINFO
    static_cast<uint32_t>(sizeof(hrr_args_hipBindTexture)),  // [16] HRR_API_HIPBINDTEXTURE
    static_cast<uint32_t>(sizeof(hrr_args_hipBindTexture2D)),  // [17] HRR_API_HIPBINDTEXTURE2D
    static_cast<uint32_t>(sizeof(hrr_args_hipBindTextureToArray)),  // [18] HRR_API_HIPBINDTEXTURETOARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipBindTextureToMipmappedArray)),  // [19] HRR_API_HIPBINDTEXTURETOMIPMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipChooseDevice)),  // [20] HRR_API_HIPCHOOSEDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipChooseDeviceR0000)),  // [21] HRR_API_HIPCHOOSEDEVICER0000
    static_cast<uint32_t>(sizeof(hrr_args_hipConfigureCall)),  // [22] HRR_API_HIPCONFIGURECALL
    static_cast<uint32_t>(sizeof(hrr_args_hipCreateSurfaceObject)),  // [23] HRR_API_HIPCREATESURFACEOBJECT
    static_cast<uint32_t>(sizeof(hrr_args_hipCreateTextureObject)),  // [24] HRR_API_HIPCREATETEXTUREOBJECT
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxCreate)),  // [25] HRR_API_HIPCTXCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxDestroy)),  // [26] HRR_API_HIPCTXDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxDisablePeerAccess)),  // [27] HRR_API_HIPCTXDISABLEPEERACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxEnablePeerAccess)),  // [28] HRR_API_HIPCTXENABLEPEERACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxGetApiVersion)),  // [29] HRR_API_HIPCTXGETAPIVERSION
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxGetCacheConfig)),  // [30] HRR_API_HIPCTXGETCACHECONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxGetCurrent)),  // [31] HRR_API_HIPCTXGETCURRENT
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxGetDevice)),  // [32] HRR_API_HIPCTXGETDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxGetFlags)),  // [33] HRR_API_HIPCTXGETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxGetSharedMemConfig)),  // [34] HRR_API_HIPCTXGETSHAREDMEMCONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxPopCurrent)),  // [35] HRR_API_HIPCTXPOPCURRENT
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxPushCurrent)),  // [36] HRR_API_HIPCTXPUSHCURRENT
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxSetCacheConfig)),  // [37] HRR_API_HIPCTXSETCACHECONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxSetCurrent)),  // [38] HRR_API_HIPCTXSETCURRENT
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxSetSharedMemConfig)),  // [39] HRR_API_HIPCTXSETSHAREDMEMCONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipCtxSynchronize)),  // [40] HRR_API_HIPCTXSYNCHRONIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipDestroyExternalMemory)),  // [41] HRR_API_HIPDESTROYEXTERNALMEMORY
    static_cast<uint32_t>(sizeof(hrr_args_hipDestroyExternalSemaphore)),  // [42] HRR_API_HIPDESTROYEXTERNALSEMAPHORE
    static_cast<uint32_t>(sizeof(hrr_args_hipDestroySurfaceObject)),  // [43] HRR_API_HIPDESTROYSURFACEOBJECT
    static_cast<uint32_t>(sizeof(hrr_args_hipDestroyTextureObject)),  // [44] HRR_API_HIPDESTROYTEXTUREOBJECT
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceCanAccessPeer)),  // [45] HRR_API_HIPDEVICECANACCESSPEER
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceComputeCapability)),  // [46] HRR_API_HIPDEVICECOMPUTECAPABILITY
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceDisablePeerAccess)),  // [47] HRR_API_HIPDEVICEDISABLEPEERACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceEnablePeerAccess)),  // [48] HRR_API_HIPDEVICEENABLEPEERACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGet)),  // [49] HRR_API_HIPDEVICEGET
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetAttribute)),  // [50] HRR_API_HIPDEVICEGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetByPCIBusId)),  // [51] HRR_API_HIPDEVICEGETBYPCIBUSID
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetCacheConfig)),  // [52] HRR_API_HIPDEVICEGETCACHECONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetDefaultMemPool)),  // [53] HRR_API_HIPDEVICEGETDEFAULTMEMPOOL
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetGraphMemAttribute)),  // [54] HRR_API_HIPDEVICEGETGRAPHMEMATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetLimit)),  // [55] HRR_API_HIPDEVICEGETLIMIT
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetMemPool)),  // [56] HRR_API_HIPDEVICEGETMEMPOOL
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetName)),  // [57] HRR_API_HIPDEVICEGETNAME
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetP2PAttribute)),  // [58] HRR_API_HIPDEVICEGETP2PATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetPCIBusId)),  // [59] HRR_API_HIPDEVICEGETPCIBUSID
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetSharedMemConfig)),  // [60] HRR_API_HIPDEVICEGETSHAREDMEMCONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetStreamPriorityRange)),  // [61] HRR_API_HIPDEVICEGETSTREAMPRIORITYRANGE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetUuid)),  // [62] HRR_API_HIPDEVICEGETUUID
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGraphMemTrim)),  // [63] HRR_API_HIPDEVICEGRAPHMEMTRIM
    static_cast<uint32_t>(sizeof(hrr_args_hipDevicePrimaryCtxGetState)),  // [64] HRR_API_HIPDEVICEPRIMARYCTXGETSTATE
    static_cast<uint32_t>(sizeof(hrr_args_hipDevicePrimaryCtxRelease)),  // [65] HRR_API_HIPDEVICEPRIMARYCTXRELEASE
    static_cast<uint32_t>(sizeof(hrr_args_hipDevicePrimaryCtxReset)),  // [66] HRR_API_HIPDEVICEPRIMARYCTXRESET
    static_cast<uint32_t>(sizeof(hrr_args_hipDevicePrimaryCtxRetain)),  // [67] HRR_API_HIPDEVICEPRIMARYCTXRETAIN
    static_cast<uint32_t>(sizeof(hrr_args_hipDevicePrimaryCtxSetFlags)),  // [68] HRR_API_HIPDEVICEPRIMARYCTXSETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceReset)),  // [69] HRR_API_HIPDEVICERESET
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceSetCacheConfig)),  // [70] HRR_API_HIPDEVICESETCACHECONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceSetGraphMemAttribute)),  // [71] HRR_API_HIPDEVICESETGRAPHMEMATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceSetLimit)),  // [72] HRR_API_HIPDEVICESETLIMIT
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceSetMemPool)),  // [73] HRR_API_HIPDEVICESETMEMPOOL
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceSetSharedMemConfig)),  // [74] HRR_API_HIPDEVICESETSHAREDMEMCONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceSynchronize)),  // [75] HRR_API_HIPDEVICESYNCHRONIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceTotalMem)),  // [76] HRR_API_HIPDEVICETOTALMEM
    static_cast<uint32_t>(sizeof(hrr_args_hipDriverGetVersion)),  // [77] HRR_API_HIPDRIVERGETVERSION
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGetErrorName)),  // [78] HRR_API_HIPDRVGETERRORNAME
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGetErrorString)),  // [79] HRR_API_HIPDRVGETERRORSTRING
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphAddMemcpyNode)),  // [80] HRR_API_HIPDRVGRAPHADDMEMCPYNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvMemcpy2DUnaligned)),  // [81] HRR_API_HIPDRVMEMCPY2DUNALIGNED
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvMemcpy3D)),  // [82] HRR_API_HIPDRVMEMCPY3D
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvMemcpy3DAsync)),  // [83] HRR_API_HIPDRVMEMCPY3DASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvPointerGetAttributes)),  // [84] HRR_API_HIPDRVPOINTERGETATTRIBUTES
    static_cast<uint32_t>(sizeof(hrr_args_hipEventCreate)),  // [85] HRR_API_HIPEVENTCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipEventCreateWithFlags)),  // [86] HRR_API_HIPEVENTCREATEWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipEventDestroy)),  // [87] HRR_API_HIPEVENTDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipEventElapsedTime)),  // [88] HRR_API_HIPEVENTELAPSEDTIME
    static_cast<uint32_t>(sizeof(hrr_args_hipEventQuery)),  // [89] HRR_API_HIPEVENTQUERY
    static_cast<uint32_t>(sizeof(hrr_args_hipEventRecord)),  // [90] HRR_API_HIPEVENTRECORD
    static_cast<uint32_t>(sizeof(hrr_args_hipEventSynchronize)),  // [91] HRR_API_HIPEVENTSYNCHRONIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipExtGetLinkTypeAndHopCount)),  // [92] HRR_API_HIPEXTGETLINKTYPEANDHOPCOUNT
    static_cast<uint32_t>(sizeof(hrr_args_hipExtLaunchKernel)),  // [93] HRR_API_HIPEXTLAUNCHKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipExtLaunchMultiKernelMultiDevice)),  // [94] HRR_API_HIPEXTLAUNCHMULTIKERNELMULTIDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipExtMallocWithFlags)),  // [95] HRR_API_HIPEXTMALLOCWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipExtStreamCreateWithCUMask)),  // [96] HRR_API_HIPEXTSTREAMCREATEWITHCUMASK
    static_cast<uint32_t>(sizeof(hrr_args_hipExtStreamGetCUMask)),  // [97] HRR_API_HIPEXTSTREAMGETCUMASK
    static_cast<uint32_t>(sizeof(hrr_args_hipExternalMemoryGetMappedBuffer)),  // [98] HRR_API_HIPEXTERNALMEMORYGETMAPPEDBUFFER
    static_cast<uint32_t>(sizeof(hrr_args_hipFree)),  // [99] HRR_API_HIPFREE
    static_cast<uint32_t>(sizeof(hrr_args_hipFreeArray)),  // [100] HRR_API_HIPFREEARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipFreeAsync)),  // [101] HRR_API_HIPFREEASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipFreeHost)),  // [102] HRR_API_HIPFREEHOST
    static_cast<uint32_t>(sizeof(hrr_args_hipFreeMipmappedArray)),  // [103] HRR_API_HIPFREEMIPMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipFuncGetAttribute)),  // [104] HRR_API_HIPFUNCGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipFuncGetAttributes)),  // [105] HRR_API_HIPFUNCGETATTRIBUTES
    static_cast<uint32_t>(sizeof(hrr_args_hipFuncSetAttribute)),  // [106] HRR_API_HIPFUNCSETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipFuncSetCacheConfig)),  // [107] HRR_API_HIPFUNCSETCACHECONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipFuncSetSharedMemConfig)),  // [108] HRR_API_HIPFUNCSETSHAREDMEMCONFIG
    static_cast<uint32_t>(sizeof(hrr_args_hipGLGetDevices)),  // [109] HRR_API_HIPGLGETDEVICES
    static_cast<uint32_t>(sizeof(hrr_args_hipGetChannelDesc)),  // [110] HRR_API_HIPGETCHANNELDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDevice)),  // [111] HRR_API_HIPGETDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDeviceCount)),  // [112] HRR_API_HIPGETDEVICECOUNT
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDeviceFlags)),  // [113] HRR_API_HIPGETDEVICEFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDevicePropertiesR0600)),  // [114] HRR_API_HIPGETDEVICEPROPERTIESR0600
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDevicePropertiesR0000)),  // [115] HRR_API_HIPGETDEVICEPROPERTIESR0000
    static_cast<uint32_t>(sizeof(hrr_args_hipGetErrorName)),  // [116] HRR_API_HIPGETERRORNAME
    static_cast<uint32_t>(sizeof(hrr_args_hipGetErrorString)),  // [117] HRR_API_HIPGETERRORSTRING
    static_cast<uint32_t>(sizeof(hrr_args_hipGetLastError)),  // [118] HRR_API_HIPGETLASTERROR
    static_cast<uint32_t>(sizeof(hrr_args_hipGetMipmappedArrayLevel)),  // [119] HRR_API_HIPGETMIPMAPPEDARRAYLEVEL
    static_cast<uint32_t>(sizeof(hrr_args_hipGetSymbolAddress)),  // [120] HRR_API_HIPGETSYMBOLADDRESS
    static_cast<uint32_t>(sizeof(hrr_args_hipGetSymbolSize)),  // [121] HRR_API_HIPGETSYMBOLSIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipGetTextureAlignmentOffset)),  // [122] HRR_API_HIPGETTEXTUREALIGNMENTOFFSET
    static_cast<uint32_t>(sizeof(hrr_args_hipGetTextureObjectResourceDesc)),  // [123] HRR_API_HIPGETTEXTUREOBJECTRESOURCEDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipGetTextureObjectResourceViewDesc)),  // [124] HRR_API_HIPGETTEXTUREOBJECTRESOURCEVIEWDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipGetTextureObjectTextureDesc)),  // [125] HRR_API_HIPGETTEXTUREOBJECTTEXTUREDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipGetTextureReference)),  // [126] HRR_API_HIPGETTEXTUREREFERENCE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddChildGraphNode)),  // [127] HRR_API_HIPGRAPHADDCHILDGRAPHNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddDependencies)),  // [128] HRR_API_HIPGRAPHADDDEPENDENCIES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddEmptyNode)),  // [129] HRR_API_HIPGRAPHADDEMPTYNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddEventRecordNode)),  // [130] HRR_API_HIPGRAPHADDEVENTRECORDNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddEventWaitNode)),  // [131] HRR_API_HIPGRAPHADDEVENTWAITNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddHostNode)),  // [132] HRR_API_HIPGRAPHADDHOSTNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddKernelNode)),  // [133] HRR_API_HIPGRAPHADDKERNELNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemAllocNode)),  // [134] HRR_API_HIPGRAPHADDMEMALLOCNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemFreeNode)),  // [135] HRR_API_HIPGRAPHADDMEMFREENODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemcpyNode)),  // [136] HRR_API_HIPGRAPHADDMEMCPYNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemcpyNode1D)),  // [137] HRR_API_HIPGRAPHADDMEMCPYNODE1D
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemcpyNodeFromSymbol)),  // [138] HRR_API_HIPGRAPHADDMEMCPYNODEFROMSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemcpyNodeToSymbol)),  // [139] HRR_API_HIPGRAPHADDMEMCPYNODETOSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddMemsetNode)),  // [140] HRR_API_HIPGRAPHADDMEMSETNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphChildGraphNodeGetGraph)),  // [141] HRR_API_HIPGRAPHCHILDGRAPHNODEGETGRAPH
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphClone)),  // [142] HRR_API_HIPGRAPHCLONE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphCreate)),  // [143] HRR_API_HIPGRAPHCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphDebugDotPrint)),  // [144] HRR_API_HIPGRAPHDEBUGDOTPRINT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphDestroy)),  // [145] HRR_API_HIPGRAPHDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphDestroyNode)),  // [146] HRR_API_HIPGRAPHDESTROYNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphEventRecordNodeGetEvent)),  // [147] HRR_API_HIPGRAPHEVENTRECORDNODEGETEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphEventRecordNodeSetEvent)),  // [148] HRR_API_HIPGRAPHEVENTRECORDNODESETEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphEventWaitNodeGetEvent)),  // [149] HRR_API_HIPGRAPHEVENTWAITNODEGETEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphEventWaitNodeSetEvent)),  // [150] HRR_API_HIPGRAPHEVENTWAITNODESETEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecChildGraphNodeSetParams)),  // [151] HRR_API_HIPGRAPHEXECCHILDGRAPHNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecDestroy)),  // [152] HRR_API_HIPGRAPHEXECDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecEventRecordNodeSetEvent)),  // [153] HRR_API_HIPGRAPHEXECEVENTRECORDNODESETEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecEventWaitNodeSetEvent)),  // [154] HRR_API_HIPGRAPHEXECEVENTWAITNODESETEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecHostNodeSetParams)),  // [155] HRR_API_HIPGRAPHEXECHOSTNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecKernelNodeSetParams)),  // [156] HRR_API_HIPGRAPHEXECKERNELNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecMemcpyNodeSetParams)),  // [157] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecMemcpyNodeSetParams1D)),  // [158] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMS1D
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecMemcpyNodeSetParamsFromSymbol)),  // [159] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMSFROMSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecMemcpyNodeSetParamsToSymbol)),  // [160] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMSTOSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecMemsetNodeSetParams)),  // [161] HRR_API_HIPGRAPHEXECMEMSETNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecUpdate)),  // [162] HRR_API_HIPGRAPHEXECUPDATE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphGetEdges)),  // [163] HRR_API_HIPGRAPHGETEDGES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphGetNodes)),  // [164] HRR_API_HIPGRAPHGETNODES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphGetRootNodes)),  // [165] HRR_API_HIPGRAPHGETROOTNODES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphHostNodeGetParams)),  // [166] HRR_API_HIPGRAPHHOSTNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphHostNodeSetParams)),  // [167] HRR_API_HIPGRAPHHOSTNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphInstantiate)),  // [168] HRR_API_HIPGRAPHINSTANTIATE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphInstantiateWithFlags)),  // [169] HRR_API_HIPGRAPHINSTANTIATEWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphKernelNodeCopyAttributes)),  // [170] HRR_API_HIPGRAPHKERNELNODECOPYATTRIBUTES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphKernelNodeGetAttribute)),  // [171] HRR_API_HIPGRAPHKERNELNODEGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphKernelNodeGetParams)),  // [172] HRR_API_HIPGRAPHKERNELNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphKernelNodeSetAttribute)),  // [173] HRR_API_HIPGRAPHKERNELNODESETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphKernelNodeSetParams)),  // [174] HRR_API_HIPGRAPHKERNELNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphLaunch)),  // [175] HRR_API_HIPGRAPHLAUNCH
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemAllocNodeGetParams)),  // [176] HRR_API_HIPGRAPHMEMALLOCNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemFreeNodeGetParams)),  // [177] HRR_API_HIPGRAPHMEMFREENODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemcpyNodeGetParams)),  // [178] HRR_API_HIPGRAPHMEMCPYNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemcpyNodeSetParams)),  // [179] HRR_API_HIPGRAPHMEMCPYNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemcpyNodeSetParams1D)),  // [180] HRR_API_HIPGRAPHMEMCPYNODESETPARAMS1D
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemcpyNodeSetParamsFromSymbol)),  // [181] HRR_API_HIPGRAPHMEMCPYNODESETPARAMSFROMSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemcpyNodeSetParamsToSymbol)),  // [182] HRR_API_HIPGRAPHMEMCPYNODESETPARAMSTOSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemsetNodeGetParams)),  // [183] HRR_API_HIPGRAPHMEMSETNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphMemsetNodeSetParams)),  // [184] HRR_API_HIPGRAPHMEMSETNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeFindInClone)),  // [185] HRR_API_HIPGRAPHNODEFINDINCLONE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeGetDependencies)),  // [186] HRR_API_HIPGRAPHNODEGETDEPENDENCIES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeGetDependentNodes)),  // [187] HRR_API_HIPGRAPHNODEGETDEPENDENTNODES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeGetEnabled)),  // [188] HRR_API_HIPGRAPHNODEGETENABLED
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeGetType)),  // [189] HRR_API_HIPGRAPHNODEGETTYPE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeSetEnabled)),  // [190] HRR_API_HIPGRAPHNODESETENABLED
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphReleaseUserObject)),  // [191] HRR_API_HIPGRAPHRELEASEUSEROBJECT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphRemoveDependencies)),  // [192] HRR_API_HIPGRAPHREMOVEDEPENDENCIES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphRetainUserObject)),  // [193] HRR_API_HIPGRAPHRETAINUSEROBJECT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphUpload)),  // [194] HRR_API_HIPGRAPHUPLOAD
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsGLRegisterBuffer)),  // [195] HRR_API_HIPGRAPHICSGLREGISTERBUFFER
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsGLRegisterImage)),  // [196] HRR_API_HIPGRAPHICSGLREGISTERIMAGE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsMapResources)),  // [197] HRR_API_HIPGRAPHICSMAPRESOURCES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsResourceGetMappedPointer)),  // [198] HRR_API_HIPGRAPHICSRESOURCEGETMAPPEDPOINTER
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsSubResourceGetMappedArray)),  // [199] HRR_API_HIPGRAPHICSSUBRESOURCEGETMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsUnmapResources)),  // [200] HRR_API_HIPGRAPHICSUNMAPRESOURCES
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphicsUnregisterResource)),  // [201] HRR_API_HIPGRAPHICSUNREGISTERRESOURCE
    static_cast<uint32_t>(sizeof(hrr_args_hipHostAlloc)),  // [202] HRR_API_HIPHOSTALLOC
    static_cast<uint32_t>(sizeof(hrr_args_hipHostFree)),  // [203] HRR_API_HIPHOSTFREE
    static_cast<uint32_t>(sizeof(hrr_args_hipHostGetDevicePointer)),  // [204] HRR_API_HIPHOSTGETDEVICEPOINTER
    static_cast<uint32_t>(sizeof(hrr_args_hipHostGetFlags)),  // [205] HRR_API_HIPHOSTGETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipHostMalloc)),  // [206] HRR_API_HIPHOSTMALLOC
    static_cast<uint32_t>(sizeof(hrr_args_hipHostRegister)),  // [207] HRR_API_HIPHOSTREGISTER
    static_cast<uint32_t>(sizeof(hrr_args_hipHostUnregister)),  // [208] HRR_API_HIPHOSTUNREGISTER
    static_cast<uint32_t>(sizeof(hrr_args_hipImportExternalMemory)),  // [209] HRR_API_HIPIMPORTEXTERNALMEMORY
    static_cast<uint32_t>(sizeof(hrr_args_hipImportExternalSemaphore)),  // [210] HRR_API_HIPIMPORTEXTERNALSEMAPHORE
    static_cast<uint32_t>(sizeof(hrr_args_hipInit)),  // [211] HRR_API_HIPINIT
    static_cast<uint32_t>(sizeof(hrr_args_hipIpcCloseMemHandle)),  // [212] HRR_API_HIPIPCCLOSEMEMHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipIpcGetEventHandle)),  // [213] HRR_API_HIPIPCGETEVENTHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipIpcGetMemHandle)),  // [214] HRR_API_HIPIPCGETMEMHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipIpcOpenEventHandle)),  // [215] HRR_API_HIPIPCOPENEVENTHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipIpcOpenMemHandle)),  // [216] HRR_API_HIPIPCOPENMEMHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelNameRef)),  // [217] HRR_API_HIPKERNELNAMEREF
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelNameRefByPtr)),  // [218] HRR_API_HIPKERNELNAMEREFBYPTR
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchByPtr)),  // [219] HRR_API_HIPLAUNCHBYPTR
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchCooperativeKernel)),  // [220] HRR_API_HIPLAUNCHCOOPERATIVEKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchCooperativeKernelMultiDevice)),  // [221] HRR_API_HIPLAUNCHCOOPERATIVEKERNELMULTIDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchHostFunc)),  // [222] HRR_API_HIPLAUNCHHOSTFUNC
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchKernel)),  // [223] HRR_API_HIPLAUNCHKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipMalloc)),  // [224] HRR_API_HIPMALLOC
    static_cast<uint32_t>(sizeof(hrr_args_hipMalloc3D)),  // [225] HRR_API_HIPMALLOC3D
    static_cast<uint32_t>(sizeof(hrr_args_hipMalloc3DArray)),  // [226] HRR_API_HIPMALLOC3DARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocArray)),  // [227] HRR_API_HIPMALLOCARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocAsync)),  // [228] HRR_API_HIPMALLOCASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocFromPoolAsync)),  // [229] HRR_API_HIPMALLOCFROMPOOLASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocHost)),  // [230] HRR_API_HIPMALLOCHOST
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocManaged)),  // [231] HRR_API_HIPMALLOCMANAGED
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocMipmappedArray)),  // [232] HRR_API_HIPMALLOCMIPMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMallocPitch)),  // [233] HRR_API_HIPMALLOCPITCH
    static_cast<uint32_t>(sizeof(hrr_args_hipMemAddressFree)),  // [234] HRR_API_HIPMEMADDRESSFREE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemAddressReserve)),  // [235] HRR_API_HIPMEMADDRESSRESERVE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemAdvise)),  // [236] HRR_API_HIPMEMADVISE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemAdvise_v2)),  // [237] HRR_API_HIPMEMADVISE_V2
    static_cast<uint32_t>(sizeof(hrr_args_hipMemAllocHost)),  // [238] HRR_API_HIPMEMALLOCHOST
    static_cast<uint32_t>(sizeof(hrr_args_hipMemAllocPitch)),  // [239] HRR_API_HIPMEMALLOCPITCH
    static_cast<uint32_t>(sizeof(hrr_args_hipMemCreate)),  // [240] HRR_API_HIPMEMCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemExportToShareableHandle)),  // [241] HRR_API_HIPMEMEXPORTTOSHAREABLEHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetAccess)),  // [242] HRR_API_HIPMEMGETACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetAddressRange)),  // [243] HRR_API_HIPMEMGETADDRESSRANGE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetAllocationGranularity)),  // [244] HRR_API_HIPMEMGETALLOCATIONGRANULARITY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetAllocationPropertiesFromHandle)),  // [245] HRR_API_HIPMEMGETALLOCATIONPROPERTIESFROMHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetInfo)),  // [246] HRR_API_HIPMEMGETINFO
    static_cast<uint32_t>(sizeof(hrr_args_hipMemImportFromShareableHandle)),  // [247] HRR_API_HIPMEMIMPORTFROMSHAREABLEHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemMap)),  // [248] HRR_API_HIPMEMMAP
    static_cast<uint32_t>(sizeof(hrr_args_hipMemMapArrayAsync)),  // [249] HRR_API_HIPMEMMAPARRAYASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolCreate)),  // [250] HRR_API_HIPMEMPOOLCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolDestroy)),  // [251] HRR_API_HIPMEMPOOLDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolExportPointer)),  // [252] HRR_API_HIPMEMPOOLEXPORTPOINTER
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolExportToShareableHandle)),  // [253] HRR_API_HIPMEMPOOLEXPORTTOSHAREABLEHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolGetAccess)),  // [254] HRR_API_HIPMEMPOOLGETACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolGetAttribute)),  // [255] HRR_API_HIPMEMPOOLGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolImportFromShareableHandle)),  // [256] HRR_API_HIPMEMPOOLIMPORTFROMSHAREABLEHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolImportPointer)),  // [257] HRR_API_HIPMEMPOOLIMPORTPOINTER
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolSetAccess)),  // [258] HRR_API_HIPMEMPOOLSETACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolSetAttribute)),  // [259] HRR_API_HIPMEMPOOLSETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPoolTrimTo)),  // [260] HRR_API_HIPMEMPOOLTRIMTO
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPrefetchAsync)),  // [261] HRR_API_HIPMEMPREFETCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPrefetchAsync_v2)),  // [262] HRR_API_HIPMEMPREFETCHASYNC_V2
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPrefetchBatchAsync)),  // [263] HRR_API_HIPMEMPREFETCHBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemDiscardBatchAsync)),  // [264] HRR_API_HIPMEMDISCARDBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvMemDiscardBatchAsync)),  // [265] HRR_API_HIPDRVMEMDISCARDBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemDiscardAndPrefetchBatchAsync)),  // [266] HRR_API_HIPMEMDISCARDANDPREFETCHBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvMemDiscardAndPrefetchBatchAsync)),  // [267] HRR_API_HIPDRVMEMDISCARDANDPREFETCHBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemPtrGetInfo)),  // [268] HRR_API_HIPMEMPTRGETINFO
    static_cast<uint32_t>(sizeof(hrr_args_hipMemRangeGetAttribute)),  // [269] HRR_API_HIPMEMRANGEGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemRangeGetAttributes)),  // [270] HRR_API_HIPMEMRANGEGETATTRIBUTES
    static_cast<uint32_t>(sizeof(hrr_args_hipMemRelease)),  // [271] HRR_API_HIPMEMRELEASE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemRetainAllocationHandle)),  // [272] HRR_API_HIPMEMRETAINALLOCATIONHANDLE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemSetAccess)),  // [273] HRR_API_HIPMEMSETACCESS
    static_cast<uint32_t>(sizeof(hrr_args_hipMemUnmap)),  // [274] HRR_API_HIPMEMUNMAP
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy)),  // [275] HRR_API_HIPMEMCPY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2D)),  // [276] HRR_API_HIPMEMCPY2D
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DAsync)),  // [277] HRR_API_HIPMEMCPY2DASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DFromArray)),  // [278] HRR_API_HIPMEMCPY2DFROMARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DFromArrayAsync)),  // [279] HRR_API_HIPMEMCPY2DFROMARRAYASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DToArray)),  // [280] HRR_API_HIPMEMCPY2DTOARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DToArrayAsync)),  // [281] HRR_API_HIPMEMCPY2DTOARRAYASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3D)),  // [282] HRR_API_HIPMEMCPY3D
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3DAsync)),  // [283] HRR_API_HIPMEMCPY3DASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyAsync)),  // [284] HRR_API_HIPMEMCPYASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyAtoH)),  // [285] HRR_API_HIPMEMCPYATOH
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyDtoD)),  // [286] HRR_API_HIPMEMCPYDTOD
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyDtoDAsync)),  // [287] HRR_API_HIPMEMCPYDTODASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyDtoH)),  // [288] HRR_API_HIPMEMCPYDTOH
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyDtoHAsync)),  // [289] HRR_API_HIPMEMCPYDTOHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyFromArray)),  // [290] HRR_API_HIPMEMCPYFROMARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyFromSymbol)),  // [291] HRR_API_HIPMEMCPYFROMSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyFromSymbolAsync)),  // [292] HRR_API_HIPMEMCPYFROMSYMBOLASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyHtoA)),  // [293] HRR_API_HIPMEMCPYHTOA
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyHtoD)),  // [294] HRR_API_HIPMEMCPYHTOD
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyHtoDAsync)),  // [295] HRR_API_HIPMEMCPYHTODASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyParam2D)),  // [296] HRR_API_HIPMEMCPYPARAM2D
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyParam2DAsync)),  // [297] HRR_API_HIPMEMCPYPARAM2DASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyPeer)),  // [298] HRR_API_HIPMEMCPYPEER
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyPeerAsync)),  // [299] HRR_API_HIPMEMCPYPEERASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyToArray)),  // [300] HRR_API_HIPMEMCPYTOARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyToSymbol)),  // [301] HRR_API_HIPMEMCPYTOSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyToSymbolAsync)),  // [302] HRR_API_HIPMEMCPYTOSYMBOLASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyWithStream)),  // [303] HRR_API_HIPMEMCPYWITHSTREAM
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset)),  // [304] HRR_API_HIPMEMSET
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset2D)),  // [305] HRR_API_HIPMEMSET2D
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset2DAsync)),  // [306] HRR_API_HIPMEMSET2DASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset3D)),  // [307] HRR_API_HIPMEMSET3D
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset3DAsync)),  // [308] HRR_API_HIPMEMSET3DASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetAsync)),  // [309] HRR_API_HIPMEMSETASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD16)),  // [310] HRR_API_HIPMEMSETD16
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD16Async)),  // [311] HRR_API_HIPMEMSETD16ASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD32)),  // [312] HRR_API_HIPMEMSETD32
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD32Async)),  // [313] HRR_API_HIPMEMSETD32ASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD8)),  // [314] HRR_API_HIPMEMSETD8
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD8Async)),  // [315] HRR_API_HIPMEMSETD8ASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMipmappedArrayCreate)),  // [316] HRR_API_HIPMIPMAPPEDARRAYCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipMipmappedArrayDestroy)),  // [317] HRR_API_HIPMIPMAPPEDARRAYDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipMipmappedArrayGetLevel)),  // [318] HRR_API_HIPMIPMAPPEDARRAYGETLEVEL
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleGetFunction)),  // [319] HRR_API_HIPMODULEGETFUNCTION
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleGetFunctionCount)),  // [320] HRR_API_HIPMODULEGETFUNCTIONCOUNT
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleGetGlobal)),  // [321] HRR_API_HIPMODULEGETGLOBAL
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleGetTexRef)),  // [322] HRR_API_HIPMODULEGETTEXREF
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLaunchCooperativeKernel)),  // [323] HRR_API_HIPMODULELAUNCHCOOPERATIVEKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLaunchCooperativeKernelMultiDevice)),  // [324] HRR_API_HIPMODULELAUNCHCOOPERATIVEKERNELMULTIDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLaunchKernel)),  // [325] HRR_API_HIPMODULELAUNCHKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLoad)),  // [326] HRR_API_HIPMODULELOAD
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLoadData)),  // [327] HRR_API_HIPMODULELOADDATA
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLoadDataEx)),  // [328] HRR_API_HIPMODULELOADDATAEX
    static_cast<uint32_t>(sizeof(hrr_args_hipLinkAddData)),  // [329] HRR_API_HIPLINKADDDATA
    static_cast<uint32_t>(sizeof(hrr_args_hipLinkAddFile)),  // [330] HRR_API_HIPLINKADDFILE
    static_cast<uint32_t>(sizeof(hrr_args_hipLinkComplete)),  // [331] HRR_API_HIPLINKCOMPLETE
    static_cast<uint32_t>(sizeof(hrr_args_hipLinkCreate)),  // [332] HRR_API_HIPLINKCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipLinkDestroy)),  // [333] HRR_API_HIPLINKDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor)),  // [334] HRR_API_HIPMODULEOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSOR
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)),  // [335] HRR_API_HIPMODULEOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSORWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleOccupancyMaxPotentialBlockSize)),  // [336] HRR_API_HIPMODULEOCCUPANCYMAXPOTENTIALBLOCKSIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleOccupancyMaxPotentialBlockSizeWithFlags)),  // [337] HRR_API_HIPMODULEOCCUPANCYMAXPOTENTIALBLOCKSIZEWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleUnload)),  // [338] HRR_API_HIPMODULEUNLOAD
    static_cast<uint32_t>(sizeof(hrr_args_hipOccupancyAvailableDynamicSMemPerBlock)),  // [339] HRR_API_HIPOCCUPANCYAVAILABLEDYNAMICSMEMPERBLOCK
    static_cast<uint32_t>(sizeof(hrr_args_hipOccupancyMaxActiveBlocksPerMultiprocessor)),  // [340] HRR_API_HIPOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSOR
    static_cast<uint32_t>(sizeof(hrr_args_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)),  // [341] HRR_API_HIPOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSORWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipOccupancyMaxPotentialBlockSize)),  // [342] HRR_API_HIPOCCUPANCYMAXPOTENTIALBLOCKSIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipOccupancyMaxActiveClusters)),  // [343] HRR_API_HIPOCCUPANCYMAXACTIVECLUSTERS
    static_cast<uint32_t>(sizeof(hrr_args_hipOccupancyMaxPotentialClusterSize)),  // [344] HRR_API_HIPOCCUPANCYMAXPOTENTIALCLUSTERSIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipPeekAtLastError)),  // [345] HRR_API_HIPPEEKATLASTERROR
    static_cast<uint32_t>(sizeof(hrr_args_hipPointerGetAttribute)),  // [346] HRR_API_HIPPOINTERGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipPointerGetAttributes)),  // [347] HRR_API_HIPPOINTERGETATTRIBUTES
    static_cast<uint32_t>(sizeof(hrr_args_hipPointerSetAttribute)),  // [348] HRR_API_HIPPOINTERSETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipProfilerStart)),  // [349] HRR_API_HIPPROFILERSTART
    static_cast<uint32_t>(sizeof(hrr_args_hipProfilerStop)),  // [350] HRR_API_HIPPROFILERSTOP
    static_cast<uint32_t>(sizeof(hrr_args_hipRuntimeGetVersion)),  // [351] HRR_API_HIPRUNTIMEGETVERSION
    static_cast<uint32_t>(sizeof(hrr_args_hipSetDevice)),  // [352] HRR_API_HIPSETDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipSetDeviceFlags)),  // [353] HRR_API_HIPSETDEVICEFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipSetupArgument)),  // [354] HRR_API_HIPSETUPARGUMENT
    static_cast<uint32_t>(sizeof(hrr_args_hipSignalExternalSemaphoresAsync)),  // [355] HRR_API_HIPSIGNALEXTERNALSEMAPHORESASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamAddCallback)),  // [356] HRR_API_HIPSTREAMADDCALLBACK
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamAttachMemAsync)),  // [357] HRR_API_HIPSTREAMATTACHMEMASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamBeginCapture)),  // [358] HRR_API_HIPSTREAMBEGINCAPTURE
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamCopyAttributes)),  // [359] HRR_API_HIPSTREAMCOPYATTRIBUTES
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamCreate)),  // [360] HRR_API_HIPSTREAMCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamCreateWithFlags)),  // [361] HRR_API_HIPSTREAMCREATEWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamCreateWithPriority)),  // [362] HRR_API_HIPSTREAMCREATEWITHPRIORITY
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamDestroy)),  // [363] HRR_API_HIPSTREAMDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamEndCapture)),  // [364] HRR_API_HIPSTREAMENDCAPTURE
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetCaptureInfo)),  // [365] HRR_API_HIPSTREAMGETCAPTUREINFO
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetCaptureInfo_v2)),  // [366] HRR_API_HIPSTREAMGETCAPTUREINFO_V2
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetDevice)),  // [367] HRR_API_HIPSTREAMGETDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetFlags)),  // [368] HRR_API_HIPSTREAMGETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetId)),  // [369] HRR_API_HIPSTREAMGETID
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetPriority)),  // [370] HRR_API_HIPSTREAMGETPRIORITY
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamIsCapturing)),  // [371] HRR_API_HIPSTREAMISCAPTURING
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamQuery)),  // [372] HRR_API_HIPSTREAMQUERY
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamSynchronize)),  // [373] HRR_API_HIPSTREAMSYNCHRONIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamUpdateCaptureDependencies)),  // [374] HRR_API_HIPSTREAMUPDATECAPTUREDEPENDENCIES
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamWaitEvent)),  // [375] HRR_API_HIPSTREAMWAITEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamWaitValue32)),  // [376] HRR_API_HIPSTREAMWAITVALUE32
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamWaitValue64)),  // [377] HRR_API_HIPSTREAMWAITVALUE64
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamWriteValue32)),  // [378] HRR_API_HIPSTREAMWRITEVALUE32
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamWriteValue64)),  // [379] HRR_API_HIPSTREAMWRITEVALUE64
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamBatchMemOp)),  // [380] HRR_API_HIPSTREAMBATCHMEMOP
    static_cast<uint32_t>(sizeof(hrr_args_hipTexObjectCreate)),  // [381] HRR_API_HIPTEXOBJECTCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexObjectDestroy)),  // [382] HRR_API_HIPTEXOBJECTDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipTexObjectGetResourceDesc)),  // [383] HRR_API_HIPTEXOBJECTGETRESOURCEDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipTexObjectGetResourceViewDesc)),  // [384] HRR_API_HIPTEXOBJECTGETRESOURCEVIEWDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipTexObjectGetTextureDesc)),  // [385] HRR_API_HIPTEXOBJECTGETTEXTUREDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetAddress)),  // [386] HRR_API_HIPTEXREFGETADDRESS
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetAddressMode)),  // [387] HRR_API_HIPTEXREFGETADDRESSMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetFilterMode)),  // [388] HRR_API_HIPTEXREFGETFILTERMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetFlags)),  // [389] HRR_API_HIPTEXREFGETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetFormat)),  // [390] HRR_API_HIPTEXREFGETFORMAT
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetMaxAnisotropy)),  // [391] HRR_API_HIPTEXREFGETMAXANISOTROPY
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetMipMappedArray)),  // [392] HRR_API_HIPTEXREFGETMIPMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetMipmapFilterMode)),  // [393] HRR_API_HIPTEXREFGETMIPMAPFILTERMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetMipmapLevelBias)),  // [394] HRR_API_HIPTEXREFGETMIPMAPLEVELBIAS
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetMipmapLevelClamp)),  // [395] HRR_API_HIPTEXREFGETMIPMAPLEVELCLAMP
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetAddress)),  // [396] HRR_API_HIPTEXREFSETADDRESS
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetAddress2D)),  // [397] HRR_API_HIPTEXREFSETADDRESS2D
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetAddressMode)),  // [398] HRR_API_HIPTEXREFSETADDRESSMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetArray)),  // [399] HRR_API_HIPTEXREFSETARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetBorderColor)),  // [400] HRR_API_HIPTEXREFSETBORDERCOLOR
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetFilterMode)),  // [401] HRR_API_HIPTEXREFSETFILTERMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetFlags)),  // [402] HRR_API_HIPTEXREFSETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetFormat)),  // [403] HRR_API_HIPTEXREFSETFORMAT
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetMaxAnisotropy)),  // [404] HRR_API_HIPTEXREFSETMAXANISOTROPY
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetMipmapFilterMode)),  // [405] HRR_API_HIPTEXREFSETMIPMAPFILTERMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetMipmapLevelBias)),  // [406] HRR_API_HIPTEXREFSETMIPMAPLEVELBIAS
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetMipmapLevelClamp)),  // [407] HRR_API_HIPTEXREFSETMIPMAPLEVELCLAMP
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefSetMipmappedArray)),  // [408] HRR_API_HIPTEXREFSETMIPMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipThreadExchangeStreamCaptureMode)),  // [409] HRR_API_HIPTHREADEXCHANGESTREAMCAPTUREMODE
    static_cast<uint32_t>(sizeof(hrr_args_hipUnbindTexture)),  // [410] HRR_API_HIPUNBINDTEXTURE
    static_cast<uint32_t>(sizeof(hrr_args_hipUserObjectCreate)),  // [411] HRR_API_HIPUSEROBJECTCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipUserObjectRelease)),  // [412] HRR_API_HIPUSEROBJECTRELEASE
    static_cast<uint32_t>(sizeof(hrr_args_hipUserObjectRetain)),  // [413] HRR_API_HIPUSEROBJECTRETAIN
    static_cast<uint32_t>(sizeof(hrr_args_hipWaitExternalSemaphoresAsync)),  // [414] HRR_API_HIPWAITEXTERNALSEMAPHORESASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy_spt)),  // [415] HRR_API_HIPMEMCPY_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyToSymbol_spt)),  // [416] HRR_API_HIPMEMCPYTOSYMBOL_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyFromSymbol_spt)),  // [417] HRR_API_HIPMEMCPYFROMSYMBOL_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2D_spt)),  // [418] HRR_API_HIPMEMCPY2D_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DFromArray_spt)),  // [419] HRR_API_HIPMEMCPY2DFROMARRAY_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3D_spt)),  // [420] HRR_API_HIPMEMCPY3D_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset_spt)),  // [421] HRR_API_HIPMEMSET_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetAsync_spt)),  // [422] HRR_API_HIPMEMSETASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset2D_spt)),  // [423] HRR_API_HIPMEMSET2D_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset2DAsync_spt)),  // [424] HRR_API_HIPMEMSET2DASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset3DAsync_spt)),  // [425] HRR_API_HIPMEMSET3DASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemset3D_spt)),  // [426] HRR_API_HIPMEMSET3D_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyAsync_spt)),  // [427] HRR_API_HIPMEMCPYASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3DAsync_spt)),  // [428] HRR_API_HIPMEMCPY3DASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DAsync_spt)),  // [429] HRR_API_HIPMEMCPY2DASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyFromSymbolAsync_spt)),  // [430] HRR_API_HIPMEMCPYFROMSYMBOLASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyToSymbolAsync_spt)),  // [431] HRR_API_HIPMEMCPYTOSYMBOLASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyFromArray_spt)),  // [432] HRR_API_HIPMEMCPYFROMARRAY_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DToArray_spt)),  // [433] HRR_API_HIPMEMCPY2DTOARRAY_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DFromArrayAsync_spt)),  // [434] HRR_API_HIPMEMCPY2DFROMARRAYASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DToArrayAsync_spt)),  // [435] HRR_API_HIPMEMCPY2DTOARRAYASYNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamQuery_spt)),  // [436] HRR_API_HIPSTREAMQUERY_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamSynchronize_spt)),  // [437] HRR_API_HIPSTREAMSYNCHRONIZE_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetPriority_spt)),  // [438] HRR_API_HIPSTREAMGETPRIORITY_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamWaitEvent_spt)),  // [439] HRR_API_HIPSTREAMWAITEVENT_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetFlags_spt)),  // [440] HRR_API_HIPSTREAMGETFLAGS_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamAddCallback_spt)),  // [441] HRR_API_HIPSTREAMADDCALLBACK_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipEventRecord_spt)),  // [442] HRR_API_HIPEVENTRECORD_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchCooperativeKernel_spt)),  // [443] HRR_API_HIPLAUNCHCOOPERATIVEKERNEL_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchKernel_spt)),  // [444] HRR_API_HIPLAUNCHKERNEL_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphLaunch_spt)),  // [445] HRR_API_HIPGRAPHLAUNCH_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamBeginCapture_spt)),  // [446] HRR_API_HIPSTREAMBEGINCAPTURE_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamEndCapture_spt)),  // [447] HRR_API_HIPSTREAMENDCAPTURE_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamIsCapturing_spt)),  // [448] HRR_API_HIPSTREAMISCAPTURING_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetCaptureInfo_spt)),  // [449] HRR_API_HIPSTREAMGETCAPTUREINFO_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetCaptureInfo_v2_spt)),  // [450] HRR_API_HIPSTREAMGETCAPTUREINFO_V2_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchHostFunc_spt)),  // [451] HRR_API_HIPLAUNCHHOSTFUNC_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipCreateChannelDesc)),  // [452] HRR_API_HIPCREATECHANNELDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipExtModuleLaunchKernel)),  // [453] HRR_API_HIPEXTMODULELAUNCHKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipHccModuleLaunchKernel)),  // [454] HRR_API_HIPHCCMODULELAUNCHKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipGetStreamDeviceId)),  // [455] HRR_API_HIPGETSTREAMDEVICEID
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphAddMemsetNode)),  // [456] HRR_API_HIPDRVGRAPHADDMEMSETNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddExternalSemaphoresWaitNode)),  // [457] HRR_API_HIPGRAPHADDEXTERNALSEMAPHORESWAITNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddExternalSemaphoresSignalNode)),  // [458] HRR_API_HIPGRAPHADDEXTERNALSEMAPHORESSIGNALNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExternalSemaphoresSignalNodeSetParams)),  // [459] HRR_API_HIPGRAPHEXTERNALSEMAPHORESSIGNALNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExternalSemaphoresWaitNodeSetParams)),  // [460] HRR_API_HIPGRAPHEXTERNALSEMAPHORESWAITNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExternalSemaphoresSignalNodeGetParams)),  // [461] HRR_API_HIPGRAPHEXTERNALSEMAPHORESSIGNALNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExternalSemaphoresWaitNodeGetParams)),  // [462] HRR_API_HIPGRAPHEXTERNALSEMAPHORESWAITNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecExternalSemaphoresSignalNodeSetParams)),  // [463] HRR_API_HIPGRAPHEXECEXTERNALSEMAPHORESSIGNALNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecExternalSemaphoresWaitNodeSetParams)),  // [464] HRR_API_HIPGRAPHEXECEXTERNALSEMAPHORESWAITNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddNode)),  // [465] HRR_API_HIPGRAPHADDNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphInstantiateWithParams)),  // [466] HRR_API_HIPGRAPHINSTANTIATEWITHPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipExtGetLastError)),  // [467] HRR_API_HIPEXTGETLASTERROR
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetBorderColor)),  // [468] HRR_API_HIPTEXREFGETBORDERCOLOR
    static_cast<uint32_t>(sizeof(hrr_args_hipTexRefGetArray)),  // [469] HRR_API_HIPTEXREFGETARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipGetProcAddress)),  // [470] HRR_API_HIPGETPROCADDRESS
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamBeginCaptureToGraph)),  // [471] HRR_API_HIPSTREAMBEGINCAPTURETOGRAPH
    static_cast<uint32_t>(sizeof(hrr_args_hipGetFuncBySymbol)),  // [472] HRR_API_HIPGETFUNCBYSYMBOL
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphAddMemFreeNode)),  // [473] HRR_API_HIPDRVGRAPHADDMEMFREENODE
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphExecMemcpyNodeSetParams)),  // [474] HRR_API_HIPDRVGRAPHEXECMEMCPYNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphExecMemsetNodeSetParams)),  // [475] HRR_API_HIPDRVGRAPHEXECMEMSETNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipSetValidDevices)),  // [476] HRR_API_HIPSETVALIDDEVICES
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyAtoD)),  // [477] HRR_API_HIPMEMCPYATOD
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyDtoA)),  // [478] HRR_API_HIPMEMCPYDTOA
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyAtoA)),  // [479] HRR_API_HIPMEMCPYATOA
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyAtoHAsync)),  // [480] HRR_API_HIPMEMCPYATOHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyHtoAAsync)),  // [481] HRR_API_HIPMEMCPYHTOAASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy2DArrayToArray)),  // [482] HRR_API_HIPMEMCPY2DARRAYTOARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecGetFlags)),  // [483] HRR_API_HIPGRAPHEXECGETFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphNodeSetParams)),  // [484] HRR_API_HIPGRAPHNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecNodeSetParams)),  // [485] HRR_API_HIPGRAPHEXECNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipExternalMemoryGetMappedMipmappedArray)),  // [486] HRR_API_HIPEXTERNALMEMORYGETMAPPEDMIPMAPPEDARRAY
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphMemcpyNodeGetParams)),  // [487] HRR_API_HIPDRVGRAPHMEMCPYNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvGraphMemcpyNodeSetParams)),  // [488] HRR_API_HIPDRVGRAPHMEMCPYNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipExtHostAlloc)),  // [489] HRR_API_HIPEXTHOSTALLOC
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetTexture1DLinearMaxWidth)),  // [490] HRR_API_HIPDEVICEGETTEXTURE1DLINEARMAXWIDTH
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphAddBatchMemOpNode)),  // [491] HRR_API_HIPGRAPHADDBATCHMEMOPNODE
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphBatchMemOpNodeGetParams)),  // [492] HRR_API_HIPGRAPHBATCHMEMOPNODEGETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphBatchMemOpNodeSetParams)),  // [493] HRR_API_HIPGRAPHBATCHMEMOPNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipGraphExecBatchMemOpNodeSetParams)),  // [494] HRR_API_HIPGRAPHEXECBATCHMEMOPNODESETPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipEventRecordWithFlags)),  // [495] HRR_API_HIPEVENTRECORDWITHFLAGS
    static_cast<uint32_t>(sizeof(hrr_args_hipLaunchKernelExC)),  // [496] HRR_API_HIPLAUNCHKERNELEXC
    static_cast<uint32_t>(sizeof(hrr_args_hipDrvLaunchKernelEx)),  // [497] HRR_API_HIPDRVLAUNCHKERNELEX
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetHandleForAddressRange)),  // [498] HRR_API_HIPMEMGETHANDLEFORADDRESSRANGE
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD2D8)),  // [499] HRR_API_HIPMEMSETD2D8
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD2D8Async)),  // [500] HRR_API_HIPMEMSETD2D8ASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD2D16)),  // [501] HRR_API_HIPMEMSETD2D16
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD2D16Async)),  // [502] HRR_API_HIPMEMSETD2D16ASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD2D32)),  // [503] HRR_API_HIPMEMSETD2D32
    static_cast<uint32_t>(sizeof(hrr_args_hipMemsetD2D32Async)),  // [504] HRR_API_HIPMEMSETD2D32ASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamSetAttribute)),  // [505] HRR_API_HIPSTREAMSETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetAttribute)),  // [506] HRR_API_HIPSTREAMGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipModuleLoadFatBinary)),  // [507] HRR_API_HIPMODULELOADFATBINARY
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpyBatchAsync)),  // [508] HRR_API_HIPMEMCPYBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3DBatchAsync)),  // [509] HRR_API_HIPMEMCPY3DBATCHASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3DPeer)),  // [510] HRR_API_HIPMEMCPY3DPEER
    static_cast<uint32_t>(sizeof(hrr_args_hipMemcpy3DPeerAsync)),  // [511] HRR_API_HIPMEMCPY3DPEERASYNC
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDriverEntryPoint)),  // [512] HRR_API_HIPGETDRIVERENTRYPOINT
    static_cast<uint32_t>(sizeof(hrr_args_hipGetDriverEntryPoint_spt)),  // [513] HRR_API_HIPGETDRIVERENTRYPOINT_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryLoadData)),  // [514] HRR_API_HIPLIBRARYLOADDATA
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryLoadFromFile)),  // [515] HRR_API_HIPLIBRARYLOADFROMFILE
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryUnload)),  // [516] HRR_API_HIPLIBRARYUNLOAD
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryGetKernel)),  // [517] HRR_API_HIPLIBRARYGETKERNEL
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryGetKernelCount)),  // [518] HRR_API_HIPLIBRARYGETKERNELCOUNT
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryGetGlobal)),  // [519] HRR_API_HIPLIBRARYGETGLOBAL
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryGetManaged)),  // [520] HRR_API_HIPLIBRARYGETMANAGED
    static_cast<uint32_t>(sizeof(hrr_args_hipLibraryEnumerateKernels)),  // [521] HRR_API_HIPLIBRARYENUMERATEKERNELS
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelGetLibrary)),  // [522] HRR_API_HIPKERNELGETLIBRARY
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelGetName)),  // [523] HRR_API_HIPKERNELGETNAME
    static_cast<uint32_t>(sizeof(hrr_args_hipGetProcAddress_spt)),  // [524] HRR_API_HIPGETPROCADDRESS_SPT
    static_cast<uint32_t>(sizeof(hrr_args_hipExtDisableLogging)),  // [525] HRR_API_HIPEXTDISABLELOGGING
    static_cast<uint32_t>(sizeof(hrr_args_hipExtEnableLogging)),  // [526] HRR_API_HIPEXTENABLELOGGING
    static_cast<uint32_t>(sizeof(hrr_args_hipExtSetLoggingParams)),  // [527] HRR_API_HIPEXTSETLOGGINGPARAMS
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelGetAttribute)),  // [528] HRR_API_HIPKERNELGETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelSetAttribute)),  // [529] HRR_API_HIPKERNELSETATTRIBUTE
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelGetFunction)),  // [530] HRR_API_HIPKERNELGETFUNCTION
    static_cast<uint32_t>(sizeof(hrr_args_hipKernelGetParamInfo)),  // [531] HRR_API_HIPKERNELGETPARAMINFO
    static_cast<uint32_t>(sizeof(hrr_args_hipMemSetMemPool)),  // [532] HRR_API_HIPMEMSETMEMPOOL
    static_cast<uint32_t>(sizeof(hrr_args_hipMemGetMemPool)),  // [533] HRR_API_HIPMEMGETMEMPOOL
    static_cast<uint32_t>(sizeof(hrr_args_hipMipmappedArrayGetMemoryRequirements)),  // [534] HRR_API_HIPMIPMAPPEDARRAYGETMEMORYREQUIREMENTS
    static_cast<uint32_t>(sizeof(hrr_args_hipGreenCtxCreate)),  // [535] HRR_API_HIPGREENCTXCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxDestroy)),  // [536] HRR_API_HIPEXECUTIONCTXDESTROY
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxStreamCreate)),  // [537] HRR_API_HIPEXECUTIONCTXSTREAMCREATE
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetDevResource)),  // [538] HRR_API_HIPDEVICEGETDEVRESOURCE
    static_cast<uint32_t>(sizeof(hrr_args_hipDevSmResourceSplitByCount)),  // [539] HRR_API_HIPDEVSMRESOURCESPLITBYCOUNT
    static_cast<uint32_t>(sizeof(hrr_args_hipDevSmResourceSplit)),  // [540] HRR_API_HIPDEVSMRESOURCESPLIT
    static_cast<uint32_t>(sizeof(hrr_args_hipDevResourceGenerateDesc)),  // [541] HRR_API_HIPDEVRESOURCEGENERATEDESC
    static_cast<uint32_t>(sizeof(hrr_args_hipDeviceGetExecutionCtx)),  // [542] HRR_API_HIPDEVICEGETEXECUTIONCTX
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxGetDevResource)),  // [543] HRR_API_HIPEXECUTIONCTXGETDEVRESOURCE
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxGetDevice)),  // [544] HRR_API_HIPEXECUTIONCTXGETDEVICE
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxGetId)),  // [545] HRR_API_HIPEXECUTIONCTXGETID
    static_cast<uint32_t>(sizeof(hrr_args_hipStreamGetDevResource)),  // [546] HRR_API_HIPSTREAMGETDEVRESOURCE
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxRecordEvent)),  // [547] HRR_API_HIPEXECUTIONCTXRECORDEVENT
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxSynchronize)),  // [548] HRR_API_HIPEXECUTIONCTXSYNCHRONIZE
    static_cast<uint32_t>(sizeof(hrr_args_hipExecutionCtxWaitEvent)),  // [549] HRR_API_HIPEXECUTIONCTXWAITEVENT
};

// ============================================================
// Playback dispatch table — indexed by hrr_api_id_t
// ============================================================
hrr_playback_fn_t hrr_playback_dispatch[HRR_API_COUNT] = {
    playback___hipPopCallConfiguration,  // [0] HRR_API_HIPPOPCALLCONFIGURATION
    playback___hipPushCallConfiguration,  // [1] HRR_API_HIPPUSHCALLCONFIGURATION
    playback___hipRegisterFatBinary,  // [2] HRR_API_HIPREGISTERFATBINARY
    playback___hipRegisterFunction,  // [3] HRR_API_HIPREGISTERFUNCTION
    playback___hipRegisterManagedVar,  // [4] HRR_API_HIPREGISTERMANAGEDVAR
    playback___hipRegisterSurface,  // [5] HRR_API_HIPREGISTERSURFACE
    playback___hipRegisterTexture,  // [6] HRR_API_HIPREGISTERTEXTURE
    playback___hipRegisterVar,  // [7] HRR_API_HIPREGISTERVAR
    playback___hipUnregisterFatBinary,  // [8] HRR_API_HIPUNREGISTERFATBINARY
    playback_hipApiName,  // [9] HRR_API_HIPAPINAME
    playback_hipArray3DCreate,  // [10] HRR_API_HIPARRAY3DCREATE
    playback_hipArray3DGetDescriptor,  // [11] HRR_API_HIPARRAY3DGETDESCRIPTOR
    playback_hipArrayCreate,  // [12] HRR_API_HIPARRAYCREATE
    playback_hipArrayDestroy,  // [13] HRR_API_HIPARRAYDESTROY
    playback_hipArrayGetDescriptor,  // [14] HRR_API_HIPARRAYGETDESCRIPTOR
    playback_hipArrayGetInfo,  // [15] HRR_API_HIPARRAYGETINFO
    playback_hipBindTexture,  // [16] HRR_API_HIPBINDTEXTURE
    playback_hipBindTexture2D,  // [17] HRR_API_HIPBINDTEXTURE2D
    playback_hipBindTextureToArray,  // [18] HRR_API_HIPBINDTEXTURETOARRAY
    playback_hipBindTextureToMipmappedArray,  // [19] HRR_API_HIPBINDTEXTURETOMIPMAPPEDARRAY
    playback_hipChooseDevice,  // [20] HRR_API_HIPCHOOSEDEVICE
    playback_hipChooseDeviceR0000,  // [21] HRR_API_HIPCHOOSEDEVICER0000
    playback_hipConfigureCall,  // [22] HRR_API_HIPCONFIGURECALL
    playback_hipCreateSurfaceObject,  // [23] HRR_API_HIPCREATESURFACEOBJECT
    playback_hipCreateTextureObject,  // [24] HRR_API_HIPCREATETEXTUREOBJECT
    playback_hipCtxCreate,  // [25] HRR_API_HIPCTXCREATE
    playback_hipCtxDestroy,  // [26] HRR_API_HIPCTXDESTROY
    playback_hipCtxDisablePeerAccess,  // [27] HRR_API_HIPCTXDISABLEPEERACCESS
    playback_hipCtxEnablePeerAccess,  // [28] HRR_API_HIPCTXENABLEPEERACCESS
    playback_hipCtxGetApiVersion,  // [29] HRR_API_HIPCTXGETAPIVERSION
    playback_hipCtxGetCacheConfig,  // [30] HRR_API_HIPCTXGETCACHECONFIG
    playback_hipCtxGetCurrent,  // [31] HRR_API_HIPCTXGETCURRENT
    playback_hipCtxGetDevice,  // [32] HRR_API_HIPCTXGETDEVICE
    playback_hipCtxGetFlags,  // [33] HRR_API_HIPCTXGETFLAGS
    playback_hipCtxGetSharedMemConfig,  // [34] HRR_API_HIPCTXGETSHAREDMEMCONFIG
    playback_hipCtxPopCurrent,  // [35] HRR_API_HIPCTXPOPCURRENT
    playback_hipCtxPushCurrent,  // [36] HRR_API_HIPCTXPUSHCURRENT
    playback_hipCtxSetCacheConfig,  // [37] HRR_API_HIPCTXSETCACHECONFIG
    playback_hipCtxSetCurrent,  // [38] HRR_API_HIPCTXSETCURRENT
    playback_hipCtxSetSharedMemConfig,  // [39] HRR_API_HIPCTXSETSHAREDMEMCONFIG
    playback_hipCtxSynchronize,  // [40] HRR_API_HIPCTXSYNCHRONIZE
    playback_hipDestroyExternalMemory,  // [41] HRR_API_HIPDESTROYEXTERNALMEMORY
    playback_hipDestroyExternalSemaphore,  // [42] HRR_API_HIPDESTROYEXTERNALSEMAPHORE
    playback_hipDestroySurfaceObject,  // [43] HRR_API_HIPDESTROYSURFACEOBJECT
    playback_hipDestroyTextureObject,  // [44] HRR_API_HIPDESTROYTEXTUREOBJECT
    playback_hipDeviceCanAccessPeer,  // [45] HRR_API_HIPDEVICECANACCESSPEER
    playback_hipDeviceComputeCapability,  // [46] HRR_API_HIPDEVICECOMPUTECAPABILITY
    playback_hipDeviceDisablePeerAccess,  // [47] HRR_API_HIPDEVICEDISABLEPEERACCESS
    playback_hipDeviceEnablePeerAccess,  // [48] HRR_API_HIPDEVICEENABLEPEERACCESS
    playback_hipDeviceGet,  // [49] HRR_API_HIPDEVICEGET
    playback_hipDeviceGetAttribute,  // [50] HRR_API_HIPDEVICEGETATTRIBUTE
    playback_hipDeviceGetByPCIBusId,  // [51] HRR_API_HIPDEVICEGETBYPCIBUSID
    playback_hipDeviceGetCacheConfig,  // [52] HRR_API_HIPDEVICEGETCACHECONFIG
    playback_hipDeviceGetDefaultMemPool,  // [53] HRR_API_HIPDEVICEGETDEFAULTMEMPOOL
    playback_hipDeviceGetGraphMemAttribute,  // [54] HRR_API_HIPDEVICEGETGRAPHMEMATTRIBUTE
    playback_hipDeviceGetLimit,  // [55] HRR_API_HIPDEVICEGETLIMIT
    playback_hipDeviceGetMemPool,  // [56] HRR_API_HIPDEVICEGETMEMPOOL
    playback_hipDeviceGetName,  // [57] HRR_API_HIPDEVICEGETNAME
    playback_hipDeviceGetP2PAttribute,  // [58] HRR_API_HIPDEVICEGETP2PATTRIBUTE
    playback_hipDeviceGetPCIBusId,  // [59] HRR_API_HIPDEVICEGETPCIBUSID
    playback_hipDeviceGetSharedMemConfig,  // [60] HRR_API_HIPDEVICEGETSHAREDMEMCONFIG
    playback_hipDeviceGetStreamPriorityRange,  // [61] HRR_API_HIPDEVICEGETSTREAMPRIORITYRANGE
    playback_hipDeviceGetUuid,  // [62] HRR_API_HIPDEVICEGETUUID
    playback_hipDeviceGraphMemTrim,  // [63] HRR_API_HIPDEVICEGRAPHMEMTRIM
    playback_hipDevicePrimaryCtxGetState,  // [64] HRR_API_HIPDEVICEPRIMARYCTXGETSTATE
    playback_hipDevicePrimaryCtxRelease,  // [65] HRR_API_HIPDEVICEPRIMARYCTXRELEASE
    playback_hipDevicePrimaryCtxReset,  // [66] HRR_API_HIPDEVICEPRIMARYCTXRESET
    playback_hipDevicePrimaryCtxRetain,  // [67] HRR_API_HIPDEVICEPRIMARYCTXRETAIN
    playback_hipDevicePrimaryCtxSetFlags,  // [68] HRR_API_HIPDEVICEPRIMARYCTXSETFLAGS
    playback_hipDeviceReset,  // [69] HRR_API_HIPDEVICERESET
    playback_hipDeviceSetCacheConfig,  // [70] HRR_API_HIPDEVICESETCACHECONFIG
    playback_hipDeviceSetGraphMemAttribute,  // [71] HRR_API_HIPDEVICESETGRAPHMEMATTRIBUTE
    playback_hipDeviceSetLimit,  // [72] HRR_API_HIPDEVICESETLIMIT
    playback_hipDeviceSetMemPool,  // [73] HRR_API_HIPDEVICESETMEMPOOL
    playback_hipDeviceSetSharedMemConfig,  // [74] HRR_API_HIPDEVICESETSHAREDMEMCONFIG
    playback_hipDeviceSynchronize,  // [75] HRR_API_HIPDEVICESYNCHRONIZE
    playback_hipDeviceTotalMem,  // [76] HRR_API_HIPDEVICETOTALMEM
    playback_hipDriverGetVersion,  // [77] HRR_API_HIPDRIVERGETVERSION
    playback_hipDrvGetErrorName,  // [78] HRR_API_HIPDRVGETERRORNAME
    playback_hipDrvGetErrorString,  // [79] HRR_API_HIPDRVGETERRORSTRING
    playback_hipDrvGraphAddMemcpyNode,  // [80] HRR_API_HIPDRVGRAPHADDMEMCPYNODE
    playback_hipDrvMemcpy2DUnaligned,  // [81] HRR_API_HIPDRVMEMCPY2DUNALIGNED
    playback_hipDrvMemcpy3D,  // [82] HRR_API_HIPDRVMEMCPY3D
    playback_hipDrvMemcpy3DAsync,  // [83] HRR_API_HIPDRVMEMCPY3DASYNC
    playback_hipDrvPointerGetAttributes,  // [84] HRR_API_HIPDRVPOINTERGETATTRIBUTES
    playback_hipEventCreate,  // [85] HRR_API_HIPEVENTCREATE
    playback_hipEventCreateWithFlags,  // [86] HRR_API_HIPEVENTCREATEWITHFLAGS
    playback_hipEventDestroy,  // [87] HRR_API_HIPEVENTDESTROY
    playback_hipEventElapsedTime,  // [88] HRR_API_HIPEVENTELAPSEDTIME
    playback_hipEventQuery,  // [89] HRR_API_HIPEVENTQUERY
    playback_hipEventRecord,  // [90] HRR_API_HIPEVENTRECORD
    playback_hipEventSynchronize,  // [91] HRR_API_HIPEVENTSYNCHRONIZE
    playback_hipExtGetLinkTypeAndHopCount,  // [92] HRR_API_HIPEXTGETLINKTYPEANDHOPCOUNT
    playback_hipExtLaunchKernel,  // [93] HRR_API_HIPEXTLAUNCHKERNEL
    playback_hipExtLaunchMultiKernelMultiDevice,  // [94] HRR_API_HIPEXTLAUNCHMULTIKERNELMULTIDEVICE
    playback_hipExtMallocWithFlags,  // [95] HRR_API_HIPEXTMALLOCWITHFLAGS
    playback_hipExtStreamCreateWithCUMask,  // [96] HRR_API_HIPEXTSTREAMCREATEWITHCUMASK
    playback_hipExtStreamGetCUMask,  // [97] HRR_API_HIPEXTSTREAMGETCUMASK
    playback_hipExternalMemoryGetMappedBuffer,  // [98] HRR_API_HIPEXTERNALMEMORYGETMAPPEDBUFFER
    playback_hipFree,  // [99] HRR_API_HIPFREE
    playback_hipFreeArray,  // [100] HRR_API_HIPFREEARRAY
    playback_hipFreeAsync,  // [101] HRR_API_HIPFREEASYNC
    playback_hipFreeHost,  // [102] HRR_API_HIPFREEHOST
    playback_hipFreeMipmappedArray,  // [103] HRR_API_HIPFREEMIPMAPPEDARRAY
    playback_hipFuncGetAttribute,  // [104] HRR_API_HIPFUNCGETATTRIBUTE
    playback_hipFuncGetAttributes,  // [105] HRR_API_HIPFUNCGETATTRIBUTES
    playback_hipFuncSetAttribute,  // [106] HRR_API_HIPFUNCSETATTRIBUTE
    playback_hipFuncSetCacheConfig,  // [107] HRR_API_HIPFUNCSETCACHECONFIG
    playback_hipFuncSetSharedMemConfig,  // [108] HRR_API_HIPFUNCSETSHAREDMEMCONFIG
    playback_hipGLGetDevices,  // [109] HRR_API_HIPGLGETDEVICES
    playback_hipGetChannelDesc,  // [110] HRR_API_HIPGETCHANNELDESC
    playback_hipGetDevice,  // [111] HRR_API_HIPGETDEVICE
    playback_hipGetDeviceCount,  // [112] HRR_API_HIPGETDEVICECOUNT
    playback_hipGetDeviceFlags,  // [113] HRR_API_HIPGETDEVICEFLAGS
    playback_hipGetDevicePropertiesR0600,  // [114] HRR_API_HIPGETDEVICEPROPERTIESR0600
    playback_hipGetDevicePropertiesR0000,  // [115] HRR_API_HIPGETDEVICEPROPERTIESR0000
    playback_hipGetErrorName,  // [116] HRR_API_HIPGETERRORNAME
    playback_hipGetErrorString,  // [117] HRR_API_HIPGETERRORSTRING
    playback_hipGetLastError,  // [118] HRR_API_HIPGETLASTERROR
    playback_hipGetMipmappedArrayLevel,  // [119] HRR_API_HIPGETMIPMAPPEDARRAYLEVEL
    playback_hipGetSymbolAddress,  // [120] HRR_API_HIPGETSYMBOLADDRESS
    playback_hipGetSymbolSize,  // [121] HRR_API_HIPGETSYMBOLSIZE
    playback_hipGetTextureAlignmentOffset,  // [122] HRR_API_HIPGETTEXTUREALIGNMENTOFFSET
    playback_hipGetTextureObjectResourceDesc,  // [123] HRR_API_HIPGETTEXTUREOBJECTRESOURCEDESC
    playback_hipGetTextureObjectResourceViewDesc,  // [124] HRR_API_HIPGETTEXTUREOBJECTRESOURCEVIEWDESC
    playback_hipGetTextureObjectTextureDesc,  // [125] HRR_API_HIPGETTEXTUREOBJECTTEXTUREDESC
    playback_hipGetTextureReference,  // [126] HRR_API_HIPGETTEXTUREREFERENCE
    playback_hipGraphAddChildGraphNode,  // [127] HRR_API_HIPGRAPHADDCHILDGRAPHNODE
    playback_hipGraphAddDependencies,  // [128] HRR_API_HIPGRAPHADDDEPENDENCIES
    playback_hipGraphAddEmptyNode,  // [129] HRR_API_HIPGRAPHADDEMPTYNODE
    playback_hipGraphAddEventRecordNode,  // [130] HRR_API_HIPGRAPHADDEVENTRECORDNODE
    playback_hipGraphAddEventWaitNode,  // [131] HRR_API_HIPGRAPHADDEVENTWAITNODE
    playback_hipGraphAddHostNode,  // [132] HRR_API_HIPGRAPHADDHOSTNODE
    playback_hipGraphAddKernelNode,  // [133] HRR_API_HIPGRAPHADDKERNELNODE
    playback_hipGraphAddMemAllocNode,  // [134] HRR_API_HIPGRAPHADDMEMALLOCNODE
    playback_hipGraphAddMemFreeNode,  // [135] HRR_API_HIPGRAPHADDMEMFREENODE
    playback_hipGraphAddMemcpyNode,  // [136] HRR_API_HIPGRAPHADDMEMCPYNODE
    playback_hipGraphAddMemcpyNode1D,  // [137] HRR_API_HIPGRAPHADDMEMCPYNODE1D
    playback_hipGraphAddMemcpyNodeFromSymbol,  // [138] HRR_API_HIPGRAPHADDMEMCPYNODEFROMSYMBOL
    playback_hipGraphAddMemcpyNodeToSymbol,  // [139] HRR_API_HIPGRAPHADDMEMCPYNODETOSYMBOL
    playback_hipGraphAddMemsetNode,  // [140] HRR_API_HIPGRAPHADDMEMSETNODE
    playback_hipGraphChildGraphNodeGetGraph,  // [141] HRR_API_HIPGRAPHCHILDGRAPHNODEGETGRAPH
    playback_hipGraphClone,  // [142] HRR_API_HIPGRAPHCLONE
    playback_hipGraphCreate,  // [143] HRR_API_HIPGRAPHCREATE
    playback_hipGraphDebugDotPrint,  // [144] HRR_API_HIPGRAPHDEBUGDOTPRINT
    playback_hipGraphDestroy,  // [145] HRR_API_HIPGRAPHDESTROY
    playback_hipGraphDestroyNode,  // [146] HRR_API_HIPGRAPHDESTROYNODE
    playback_hipGraphEventRecordNodeGetEvent,  // [147] HRR_API_HIPGRAPHEVENTRECORDNODEGETEVENT
    playback_hipGraphEventRecordNodeSetEvent,  // [148] HRR_API_HIPGRAPHEVENTRECORDNODESETEVENT
    playback_hipGraphEventWaitNodeGetEvent,  // [149] HRR_API_HIPGRAPHEVENTWAITNODEGETEVENT
    playback_hipGraphEventWaitNodeSetEvent,  // [150] HRR_API_HIPGRAPHEVENTWAITNODESETEVENT
    playback_hipGraphExecChildGraphNodeSetParams,  // [151] HRR_API_HIPGRAPHEXECCHILDGRAPHNODESETPARAMS
    playback_hipGraphExecDestroy,  // [152] HRR_API_HIPGRAPHEXECDESTROY
    playback_hipGraphExecEventRecordNodeSetEvent,  // [153] HRR_API_HIPGRAPHEXECEVENTRECORDNODESETEVENT
    playback_hipGraphExecEventWaitNodeSetEvent,  // [154] HRR_API_HIPGRAPHEXECEVENTWAITNODESETEVENT
    playback_hipGraphExecHostNodeSetParams,  // [155] HRR_API_HIPGRAPHEXECHOSTNODESETPARAMS
    playback_hipGraphExecKernelNodeSetParams,  // [156] HRR_API_HIPGRAPHEXECKERNELNODESETPARAMS
    playback_hipGraphExecMemcpyNodeSetParams,  // [157] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMS
    playback_hipGraphExecMemcpyNodeSetParams1D,  // [158] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMS1D
    playback_hipGraphExecMemcpyNodeSetParamsFromSymbol,  // [159] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMSFROMSYMBOL
    playback_hipGraphExecMemcpyNodeSetParamsToSymbol,  // [160] HRR_API_HIPGRAPHEXECMEMCPYNODESETPARAMSTOSYMBOL
    playback_hipGraphExecMemsetNodeSetParams,  // [161] HRR_API_HIPGRAPHEXECMEMSETNODESETPARAMS
    playback_hipGraphExecUpdate,  // [162] HRR_API_HIPGRAPHEXECUPDATE
    playback_hipGraphGetEdges,  // [163] HRR_API_HIPGRAPHGETEDGES
    playback_hipGraphGetNodes,  // [164] HRR_API_HIPGRAPHGETNODES
    playback_hipGraphGetRootNodes,  // [165] HRR_API_HIPGRAPHGETROOTNODES
    playback_hipGraphHostNodeGetParams,  // [166] HRR_API_HIPGRAPHHOSTNODEGETPARAMS
    playback_hipGraphHostNodeSetParams,  // [167] HRR_API_HIPGRAPHHOSTNODESETPARAMS
    playback_hipGraphInstantiate,  // [168] HRR_API_HIPGRAPHINSTANTIATE
    playback_hipGraphInstantiateWithFlags,  // [169] HRR_API_HIPGRAPHINSTANTIATEWITHFLAGS
    playback_hipGraphKernelNodeCopyAttributes,  // [170] HRR_API_HIPGRAPHKERNELNODECOPYATTRIBUTES
    playback_hipGraphKernelNodeGetAttribute,  // [171] HRR_API_HIPGRAPHKERNELNODEGETATTRIBUTE
    playback_hipGraphKernelNodeGetParams,  // [172] HRR_API_HIPGRAPHKERNELNODEGETPARAMS
    playback_hipGraphKernelNodeSetAttribute,  // [173] HRR_API_HIPGRAPHKERNELNODESETATTRIBUTE
    playback_hipGraphKernelNodeSetParams,  // [174] HRR_API_HIPGRAPHKERNELNODESETPARAMS
    playback_hipGraphLaunch,  // [175] HRR_API_HIPGRAPHLAUNCH
    playback_hipGraphMemAllocNodeGetParams,  // [176] HRR_API_HIPGRAPHMEMALLOCNODEGETPARAMS
    playback_hipGraphMemFreeNodeGetParams,  // [177] HRR_API_HIPGRAPHMEMFREENODEGETPARAMS
    playback_hipGraphMemcpyNodeGetParams,  // [178] HRR_API_HIPGRAPHMEMCPYNODEGETPARAMS
    playback_hipGraphMemcpyNodeSetParams,  // [179] HRR_API_HIPGRAPHMEMCPYNODESETPARAMS
    playback_hipGraphMemcpyNodeSetParams1D,  // [180] HRR_API_HIPGRAPHMEMCPYNODESETPARAMS1D
    playback_hipGraphMemcpyNodeSetParamsFromSymbol,  // [181] HRR_API_HIPGRAPHMEMCPYNODESETPARAMSFROMSYMBOL
    playback_hipGraphMemcpyNodeSetParamsToSymbol,  // [182] HRR_API_HIPGRAPHMEMCPYNODESETPARAMSTOSYMBOL
    playback_hipGraphMemsetNodeGetParams,  // [183] HRR_API_HIPGRAPHMEMSETNODEGETPARAMS
    playback_hipGraphMemsetNodeSetParams,  // [184] HRR_API_HIPGRAPHMEMSETNODESETPARAMS
    playback_hipGraphNodeFindInClone,  // [185] HRR_API_HIPGRAPHNODEFINDINCLONE
    playback_hipGraphNodeGetDependencies,  // [186] HRR_API_HIPGRAPHNODEGETDEPENDENCIES
    playback_hipGraphNodeGetDependentNodes,  // [187] HRR_API_HIPGRAPHNODEGETDEPENDENTNODES
    playback_hipGraphNodeGetEnabled,  // [188] HRR_API_HIPGRAPHNODEGETENABLED
    playback_hipGraphNodeGetType,  // [189] HRR_API_HIPGRAPHNODEGETTYPE
    playback_hipGraphNodeSetEnabled,  // [190] HRR_API_HIPGRAPHNODESETENABLED
    playback_hipGraphReleaseUserObject,  // [191] HRR_API_HIPGRAPHRELEASEUSEROBJECT
    playback_hipGraphRemoveDependencies,  // [192] HRR_API_HIPGRAPHREMOVEDEPENDENCIES
    playback_hipGraphRetainUserObject,  // [193] HRR_API_HIPGRAPHRETAINUSEROBJECT
    playback_hipGraphUpload,  // [194] HRR_API_HIPGRAPHUPLOAD
    playback_hipGraphicsGLRegisterBuffer,  // [195] HRR_API_HIPGRAPHICSGLREGISTERBUFFER
    playback_hipGraphicsGLRegisterImage,  // [196] HRR_API_HIPGRAPHICSGLREGISTERIMAGE
    playback_hipGraphicsMapResources,  // [197] HRR_API_HIPGRAPHICSMAPRESOURCES
    playback_hipGraphicsResourceGetMappedPointer,  // [198] HRR_API_HIPGRAPHICSRESOURCEGETMAPPEDPOINTER
    playback_hipGraphicsSubResourceGetMappedArray,  // [199] HRR_API_HIPGRAPHICSSUBRESOURCEGETMAPPEDARRAY
    playback_hipGraphicsUnmapResources,  // [200] HRR_API_HIPGRAPHICSUNMAPRESOURCES
    playback_hipGraphicsUnregisterResource,  // [201] HRR_API_HIPGRAPHICSUNREGISTERRESOURCE
    playback_hipHostAlloc,  // [202] HRR_API_HIPHOSTALLOC
    playback_hipHostFree,  // [203] HRR_API_HIPHOSTFREE
    playback_hipHostGetDevicePointer,  // [204] HRR_API_HIPHOSTGETDEVICEPOINTER
    playback_hipHostGetFlags,  // [205] HRR_API_HIPHOSTGETFLAGS
    playback_hipHostMalloc,  // [206] HRR_API_HIPHOSTMALLOC
    playback_hipHostRegister,  // [207] HRR_API_HIPHOSTREGISTER
    playback_hipHostUnregister,  // [208] HRR_API_HIPHOSTUNREGISTER
    playback_hipImportExternalMemory,  // [209] HRR_API_HIPIMPORTEXTERNALMEMORY
    playback_hipImportExternalSemaphore,  // [210] HRR_API_HIPIMPORTEXTERNALSEMAPHORE
    playback_hipInit,  // [211] HRR_API_HIPINIT
    playback_hipIpcCloseMemHandle,  // [212] HRR_API_HIPIPCCLOSEMEMHANDLE
    playback_hipIpcGetEventHandle,  // [213] HRR_API_HIPIPCGETEVENTHANDLE
    playback_hipIpcGetMemHandle,  // [214] HRR_API_HIPIPCGETMEMHANDLE
    playback_hipIpcOpenEventHandle,  // [215] HRR_API_HIPIPCOPENEVENTHANDLE
    playback_hipIpcOpenMemHandle,  // [216] HRR_API_HIPIPCOPENMEMHANDLE
    playback_hipKernelNameRef,  // [217] HRR_API_HIPKERNELNAMEREF
    playback_hipKernelNameRefByPtr,  // [218] HRR_API_HIPKERNELNAMEREFBYPTR
    playback_hipLaunchByPtr,  // [219] HRR_API_HIPLAUNCHBYPTR
    playback_hipLaunchCooperativeKernel,  // [220] HRR_API_HIPLAUNCHCOOPERATIVEKERNEL
    playback_hipLaunchCooperativeKernelMultiDevice,  // [221] HRR_API_HIPLAUNCHCOOPERATIVEKERNELMULTIDEVICE
    playback_hipLaunchHostFunc,  // [222] HRR_API_HIPLAUNCHHOSTFUNC
    playback_hipLaunchKernel,  // [223] HRR_API_HIPLAUNCHKERNEL
    playback_hipMalloc,  // [224] HRR_API_HIPMALLOC
    playback_hipMalloc3D,  // [225] HRR_API_HIPMALLOC3D
    playback_hipMalloc3DArray,  // [226] HRR_API_HIPMALLOC3DARRAY
    playback_hipMallocArray,  // [227] HRR_API_HIPMALLOCARRAY
    playback_hipMallocAsync,  // [228] HRR_API_HIPMALLOCASYNC
    playback_hipMallocFromPoolAsync,  // [229] HRR_API_HIPMALLOCFROMPOOLASYNC
    playback_hipMallocHost,  // [230] HRR_API_HIPMALLOCHOST
    playback_hipMallocManaged,  // [231] HRR_API_HIPMALLOCMANAGED
    playback_hipMallocMipmappedArray,  // [232] HRR_API_HIPMALLOCMIPMAPPEDARRAY
    playback_hipMallocPitch,  // [233] HRR_API_HIPMALLOCPITCH
    playback_hipMemAddressFree,  // [234] HRR_API_HIPMEMADDRESSFREE
    playback_hipMemAddressReserve,  // [235] HRR_API_HIPMEMADDRESSRESERVE
    playback_hipMemAdvise,  // [236] HRR_API_HIPMEMADVISE
    playback_hipMemAdvise_v2,  // [237] HRR_API_HIPMEMADVISE_V2
    playback_hipMemAllocHost,  // [238] HRR_API_HIPMEMALLOCHOST
    playback_hipMemAllocPitch,  // [239] HRR_API_HIPMEMALLOCPITCH
    playback_hipMemCreate,  // [240] HRR_API_HIPMEMCREATE
    playback_hipMemExportToShareableHandle,  // [241] HRR_API_HIPMEMEXPORTTOSHAREABLEHANDLE
    playback_hipMemGetAccess,  // [242] HRR_API_HIPMEMGETACCESS
    playback_hipMemGetAddressRange,  // [243] HRR_API_HIPMEMGETADDRESSRANGE
    playback_hipMemGetAllocationGranularity,  // [244] HRR_API_HIPMEMGETALLOCATIONGRANULARITY
    playback_hipMemGetAllocationPropertiesFromHandle,  // [245] HRR_API_HIPMEMGETALLOCATIONPROPERTIESFROMHANDLE
    playback_hipMemGetInfo,  // [246] HRR_API_HIPMEMGETINFO
    playback_hipMemImportFromShareableHandle,  // [247] HRR_API_HIPMEMIMPORTFROMSHAREABLEHANDLE
    playback_hipMemMap,  // [248] HRR_API_HIPMEMMAP
    playback_hipMemMapArrayAsync,  // [249] HRR_API_HIPMEMMAPARRAYASYNC
    playback_hipMemPoolCreate,  // [250] HRR_API_HIPMEMPOOLCREATE
    playback_hipMemPoolDestroy,  // [251] HRR_API_HIPMEMPOOLDESTROY
    playback_hipMemPoolExportPointer,  // [252] HRR_API_HIPMEMPOOLEXPORTPOINTER
    playback_hipMemPoolExportToShareableHandle,  // [253] HRR_API_HIPMEMPOOLEXPORTTOSHAREABLEHANDLE
    playback_hipMemPoolGetAccess,  // [254] HRR_API_HIPMEMPOOLGETACCESS
    playback_hipMemPoolGetAttribute,  // [255] HRR_API_HIPMEMPOOLGETATTRIBUTE
    playback_hipMemPoolImportFromShareableHandle,  // [256] HRR_API_HIPMEMPOOLIMPORTFROMSHAREABLEHANDLE
    playback_hipMemPoolImportPointer,  // [257] HRR_API_HIPMEMPOOLIMPORTPOINTER
    playback_hipMemPoolSetAccess,  // [258] HRR_API_HIPMEMPOOLSETACCESS
    playback_hipMemPoolSetAttribute,  // [259] HRR_API_HIPMEMPOOLSETATTRIBUTE
    playback_hipMemPoolTrimTo,  // [260] HRR_API_HIPMEMPOOLTRIMTO
    playback_hipMemPrefetchAsync,  // [261] HRR_API_HIPMEMPREFETCHASYNC
    playback_hipMemPrefetchAsync_v2,  // [262] HRR_API_HIPMEMPREFETCHASYNC_V2
    playback_hipMemPrefetchBatchAsync,  // [263] HRR_API_HIPMEMPREFETCHBATCHASYNC
    playback_hipMemDiscardBatchAsync,  // [264] HRR_API_HIPMEMDISCARDBATCHASYNC
    playback_hipDrvMemDiscardBatchAsync,  // [265] HRR_API_HIPDRVMEMDISCARDBATCHASYNC
    playback_hipMemDiscardAndPrefetchBatchAsync,  // [266] HRR_API_HIPMEMDISCARDANDPREFETCHBATCHASYNC
    playback_hipDrvMemDiscardAndPrefetchBatchAsync,  // [267] HRR_API_HIPDRVMEMDISCARDANDPREFETCHBATCHASYNC
    playback_hipMemPtrGetInfo,  // [268] HRR_API_HIPMEMPTRGETINFO
    playback_hipMemRangeGetAttribute,  // [269] HRR_API_HIPMEMRANGEGETATTRIBUTE
    playback_hipMemRangeGetAttributes,  // [270] HRR_API_HIPMEMRANGEGETATTRIBUTES
    playback_hipMemRelease,  // [271] HRR_API_HIPMEMRELEASE
    playback_hipMemRetainAllocationHandle,  // [272] HRR_API_HIPMEMRETAINALLOCATIONHANDLE
    playback_hipMemSetAccess,  // [273] HRR_API_HIPMEMSETACCESS
    playback_hipMemUnmap,  // [274] HRR_API_HIPMEMUNMAP
    playback_hipMemcpy,  // [275] HRR_API_HIPMEMCPY
    playback_hipMemcpy2D,  // [276] HRR_API_HIPMEMCPY2D
    playback_hipMemcpy2DAsync,  // [277] HRR_API_HIPMEMCPY2DASYNC
    playback_hipMemcpy2DFromArray,  // [278] HRR_API_HIPMEMCPY2DFROMARRAY
    playback_hipMemcpy2DFromArrayAsync,  // [279] HRR_API_HIPMEMCPY2DFROMARRAYASYNC
    playback_hipMemcpy2DToArray,  // [280] HRR_API_HIPMEMCPY2DTOARRAY
    playback_hipMemcpy2DToArrayAsync,  // [281] HRR_API_HIPMEMCPY2DTOARRAYASYNC
    playback_hipMemcpy3D,  // [282] HRR_API_HIPMEMCPY3D
    playback_hipMemcpy3DAsync,  // [283] HRR_API_HIPMEMCPY3DASYNC
    playback_hipMemcpyAsync,  // [284] HRR_API_HIPMEMCPYASYNC
    playback_hipMemcpyAtoH,  // [285] HRR_API_HIPMEMCPYATOH
    playback_hipMemcpyDtoD,  // [286] HRR_API_HIPMEMCPYDTOD
    playback_hipMemcpyDtoDAsync,  // [287] HRR_API_HIPMEMCPYDTODASYNC
    playback_hipMemcpyDtoH,  // [288] HRR_API_HIPMEMCPYDTOH
    playback_hipMemcpyDtoHAsync,  // [289] HRR_API_HIPMEMCPYDTOHASYNC
    playback_hipMemcpyFromArray,  // [290] HRR_API_HIPMEMCPYFROMARRAY
    playback_hipMemcpyFromSymbol,  // [291] HRR_API_HIPMEMCPYFROMSYMBOL
    playback_hipMemcpyFromSymbolAsync,  // [292] HRR_API_HIPMEMCPYFROMSYMBOLASYNC
    playback_hipMemcpyHtoA,  // [293] HRR_API_HIPMEMCPYHTOA
    playback_hipMemcpyHtoD,  // [294] HRR_API_HIPMEMCPYHTOD
    playback_hipMemcpyHtoDAsync,  // [295] HRR_API_HIPMEMCPYHTODASYNC
    playback_hipMemcpyParam2D,  // [296] HRR_API_HIPMEMCPYPARAM2D
    playback_hipMemcpyParam2DAsync,  // [297] HRR_API_HIPMEMCPYPARAM2DASYNC
    playback_hipMemcpyPeer,  // [298] HRR_API_HIPMEMCPYPEER
    playback_hipMemcpyPeerAsync,  // [299] HRR_API_HIPMEMCPYPEERASYNC
    playback_hipMemcpyToArray,  // [300] HRR_API_HIPMEMCPYTOARRAY
    playback_hipMemcpyToSymbol,  // [301] HRR_API_HIPMEMCPYTOSYMBOL
    playback_hipMemcpyToSymbolAsync,  // [302] HRR_API_HIPMEMCPYTOSYMBOLASYNC
    playback_hipMemcpyWithStream,  // [303] HRR_API_HIPMEMCPYWITHSTREAM
    playback_hipMemset,  // [304] HRR_API_HIPMEMSET
    playback_hipMemset2D,  // [305] HRR_API_HIPMEMSET2D
    playback_hipMemset2DAsync,  // [306] HRR_API_HIPMEMSET2DASYNC
    playback_hipMemset3D,  // [307] HRR_API_HIPMEMSET3D
    playback_hipMemset3DAsync,  // [308] HRR_API_HIPMEMSET3DASYNC
    playback_hipMemsetAsync,  // [309] HRR_API_HIPMEMSETASYNC
    playback_hipMemsetD16,  // [310] HRR_API_HIPMEMSETD16
    playback_hipMemsetD16Async,  // [311] HRR_API_HIPMEMSETD16ASYNC
    playback_hipMemsetD32,  // [312] HRR_API_HIPMEMSETD32
    playback_hipMemsetD32Async,  // [313] HRR_API_HIPMEMSETD32ASYNC
    playback_hipMemsetD8,  // [314] HRR_API_HIPMEMSETD8
    playback_hipMemsetD8Async,  // [315] HRR_API_HIPMEMSETD8ASYNC
    playback_hipMipmappedArrayCreate,  // [316] HRR_API_HIPMIPMAPPEDARRAYCREATE
    playback_hipMipmappedArrayDestroy,  // [317] HRR_API_HIPMIPMAPPEDARRAYDESTROY
    playback_hipMipmappedArrayGetLevel,  // [318] HRR_API_HIPMIPMAPPEDARRAYGETLEVEL
    playback_hipModuleGetFunction,  // [319] HRR_API_HIPMODULEGETFUNCTION
    playback_hipModuleGetFunctionCount,  // [320] HRR_API_HIPMODULEGETFUNCTIONCOUNT
    playback_hipModuleGetGlobal,  // [321] HRR_API_HIPMODULEGETGLOBAL
    playback_hipModuleGetTexRef,  // [322] HRR_API_HIPMODULEGETTEXREF
    playback_hipModuleLaunchCooperativeKernel,  // [323] HRR_API_HIPMODULELAUNCHCOOPERATIVEKERNEL
    playback_hipModuleLaunchCooperativeKernelMultiDevice,  // [324] HRR_API_HIPMODULELAUNCHCOOPERATIVEKERNELMULTIDEVICE
    playback_hipModuleLaunchKernel,  // [325] HRR_API_HIPMODULELAUNCHKERNEL
    playback_hipModuleLoad,  // [326] HRR_API_HIPMODULELOAD
    playback_hipModuleLoadData,  // [327] HRR_API_HIPMODULELOADDATA
    playback_hipModuleLoadDataEx,  // [328] HRR_API_HIPMODULELOADDATAEX
    playback_hipLinkAddData,  // [329] HRR_API_HIPLINKADDDATA
    playback_hipLinkAddFile,  // [330] HRR_API_HIPLINKADDFILE
    playback_hipLinkComplete,  // [331] HRR_API_HIPLINKCOMPLETE
    playback_hipLinkCreate,  // [332] HRR_API_HIPLINKCREATE
    playback_hipLinkDestroy,  // [333] HRR_API_HIPLINKDESTROY
    playback_hipModuleOccupancyMaxActiveBlocksPerMultiprocessor,  // [334] HRR_API_HIPMODULEOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSOR
    playback_hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags,  // [335] HRR_API_HIPMODULEOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSORWITHFLAGS
    playback_hipModuleOccupancyMaxPotentialBlockSize,  // [336] HRR_API_HIPMODULEOCCUPANCYMAXPOTENTIALBLOCKSIZE
    playback_hipModuleOccupancyMaxPotentialBlockSizeWithFlags,  // [337] HRR_API_HIPMODULEOCCUPANCYMAXPOTENTIALBLOCKSIZEWITHFLAGS
    playback_hipModuleUnload,  // [338] HRR_API_HIPMODULEUNLOAD
    playback_hipOccupancyAvailableDynamicSMemPerBlock,  // [339] HRR_API_HIPOCCUPANCYAVAILABLEDYNAMICSMEMPERBLOCK
    playback_hipOccupancyMaxActiveBlocksPerMultiprocessor,  // [340] HRR_API_HIPOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSOR
    playback_hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags,  // [341] HRR_API_HIPOCCUPANCYMAXACTIVEBLOCKSPERMULTIPROCESSORWITHFLAGS
    playback_hipOccupancyMaxPotentialBlockSize,  // [342] HRR_API_HIPOCCUPANCYMAXPOTENTIALBLOCKSIZE
    playback_hipOccupancyMaxActiveClusters,  // [343] HRR_API_HIPOCCUPANCYMAXACTIVECLUSTERS
    playback_hipOccupancyMaxPotentialClusterSize,  // [344] HRR_API_HIPOCCUPANCYMAXPOTENTIALCLUSTERSIZE
    playback_hipPeekAtLastError,  // [345] HRR_API_HIPPEEKATLASTERROR
    playback_hipPointerGetAttribute,  // [346] HRR_API_HIPPOINTERGETATTRIBUTE
    playback_hipPointerGetAttributes,  // [347] HRR_API_HIPPOINTERGETATTRIBUTES
    playback_hipPointerSetAttribute,  // [348] HRR_API_HIPPOINTERSETATTRIBUTE
    playback_hipProfilerStart,  // [349] HRR_API_HIPPROFILERSTART
    playback_hipProfilerStop,  // [350] HRR_API_HIPPROFILERSTOP
    playback_hipRuntimeGetVersion,  // [351] HRR_API_HIPRUNTIMEGETVERSION
    playback_hipSetDevice,  // [352] HRR_API_HIPSETDEVICE
    playback_hipSetDeviceFlags,  // [353] HRR_API_HIPSETDEVICEFLAGS
    playback_hipSetupArgument,  // [354] HRR_API_HIPSETUPARGUMENT
    playback_hipSignalExternalSemaphoresAsync,  // [355] HRR_API_HIPSIGNALEXTERNALSEMAPHORESASYNC
    playback_hipStreamAddCallback,  // [356] HRR_API_HIPSTREAMADDCALLBACK
    playback_hipStreamAttachMemAsync,  // [357] HRR_API_HIPSTREAMATTACHMEMASYNC
    playback_hipStreamBeginCapture,  // [358] HRR_API_HIPSTREAMBEGINCAPTURE
    playback_hipStreamCopyAttributes,  // [359] HRR_API_HIPSTREAMCOPYATTRIBUTES
    playback_hipStreamCreate,  // [360] HRR_API_HIPSTREAMCREATE
    playback_hipStreamCreateWithFlags,  // [361] HRR_API_HIPSTREAMCREATEWITHFLAGS
    playback_hipStreamCreateWithPriority,  // [362] HRR_API_HIPSTREAMCREATEWITHPRIORITY
    playback_hipStreamDestroy,  // [363] HRR_API_HIPSTREAMDESTROY
    playback_hipStreamEndCapture,  // [364] HRR_API_HIPSTREAMENDCAPTURE
    playback_hipStreamGetCaptureInfo,  // [365] HRR_API_HIPSTREAMGETCAPTUREINFO
    playback_hipStreamGetCaptureInfo_v2,  // [366] HRR_API_HIPSTREAMGETCAPTUREINFO_V2
    playback_hipStreamGetDevice,  // [367] HRR_API_HIPSTREAMGETDEVICE
    playback_hipStreamGetFlags,  // [368] HRR_API_HIPSTREAMGETFLAGS
    playback_hipStreamGetId,  // [369] HRR_API_HIPSTREAMGETID
    playback_hipStreamGetPriority,  // [370] HRR_API_HIPSTREAMGETPRIORITY
    playback_hipStreamIsCapturing,  // [371] HRR_API_HIPSTREAMISCAPTURING
    playback_hipStreamQuery,  // [372] HRR_API_HIPSTREAMQUERY
    playback_hipStreamSynchronize,  // [373] HRR_API_HIPSTREAMSYNCHRONIZE
    playback_hipStreamUpdateCaptureDependencies,  // [374] HRR_API_HIPSTREAMUPDATECAPTUREDEPENDENCIES
    playback_hipStreamWaitEvent,  // [375] HRR_API_HIPSTREAMWAITEVENT
    playback_hipStreamWaitValue32,  // [376] HRR_API_HIPSTREAMWAITVALUE32
    playback_hipStreamWaitValue64,  // [377] HRR_API_HIPSTREAMWAITVALUE64
    playback_hipStreamWriteValue32,  // [378] HRR_API_HIPSTREAMWRITEVALUE32
    playback_hipStreamWriteValue64,  // [379] HRR_API_HIPSTREAMWRITEVALUE64
    playback_hipStreamBatchMemOp,  // [380] HRR_API_HIPSTREAMBATCHMEMOP
    playback_hipTexObjectCreate,  // [381] HRR_API_HIPTEXOBJECTCREATE
    playback_hipTexObjectDestroy,  // [382] HRR_API_HIPTEXOBJECTDESTROY
    playback_hipTexObjectGetResourceDesc,  // [383] HRR_API_HIPTEXOBJECTGETRESOURCEDESC
    playback_hipTexObjectGetResourceViewDesc,  // [384] HRR_API_HIPTEXOBJECTGETRESOURCEVIEWDESC
    playback_hipTexObjectGetTextureDesc,  // [385] HRR_API_HIPTEXOBJECTGETTEXTUREDESC
    playback_hipTexRefGetAddress,  // [386] HRR_API_HIPTEXREFGETADDRESS
    playback_hipTexRefGetAddressMode,  // [387] HRR_API_HIPTEXREFGETADDRESSMODE
    playback_hipTexRefGetFilterMode,  // [388] HRR_API_HIPTEXREFGETFILTERMODE
    playback_hipTexRefGetFlags,  // [389] HRR_API_HIPTEXREFGETFLAGS
    playback_hipTexRefGetFormat,  // [390] HRR_API_HIPTEXREFGETFORMAT
    playback_hipTexRefGetMaxAnisotropy,  // [391] HRR_API_HIPTEXREFGETMAXANISOTROPY
    playback_hipTexRefGetMipMappedArray,  // [392] HRR_API_HIPTEXREFGETMIPMAPPEDARRAY
    playback_hipTexRefGetMipmapFilterMode,  // [393] HRR_API_HIPTEXREFGETMIPMAPFILTERMODE
    playback_hipTexRefGetMipmapLevelBias,  // [394] HRR_API_HIPTEXREFGETMIPMAPLEVELBIAS
    playback_hipTexRefGetMipmapLevelClamp,  // [395] HRR_API_HIPTEXREFGETMIPMAPLEVELCLAMP
    playback_hipTexRefSetAddress,  // [396] HRR_API_HIPTEXREFSETADDRESS
    playback_hipTexRefSetAddress2D,  // [397] HRR_API_HIPTEXREFSETADDRESS2D
    playback_hipTexRefSetAddressMode,  // [398] HRR_API_HIPTEXREFSETADDRESSMODE
    playback_hipTexRefSetArray,  // [399] HRR_API_HIPTEXREFSETARRAY
    playback_hipTexRefSetBorderColor,  // [400] HRR_API_HIPTEXREFSETBORDERCOLOR
    playback_hipTexRefSetFilterMode,  // [401] HRR_API_HIPTEXREFSETFILTERMODE
    playback_hipTexRefSetFlags,  // [402] HRR_API_HIPTEXREFSETFLAGS
    playback_hipTexRefSetFormat,  // [403] HRR_API_HIPTEXREFSETFORMAT
    playback_hipTexRefSetMaxAnisotropy,  // [404] HRR_API_HIPTEXREFSETMAXANISOTROPY
    playback_hipTexRefSetMipmapFilterMode,  // [405] HRR_API_HIPTEXREFSETMIPMAPFILTERMODE
    playback_hipTexRefSetMipmapLevelBias,  // [406] HRR_API_HIPTEXREFSETMIPMAPLEVELBIAS
    playback_hipTexRefSetMipmapLevelClamp,  // [407] HRR_API_HIPTEXREFSETMIPMAPLEVELCLAMP
    playback_hipTexRefSetMipmappedArray,  // [408] HRR_API_HIPTEXREFSETMIPMAPPEDARRAY
    playback_hipThreadExchangeStreamCaptureMode,  // [409] HRR_API_HIPTHREADEXCHANGESTREAMCAPTUREMODE
    playback_hipUnbindTexture,  // [410] HRR_API_HIPUNBINDTEXTURE
    playback_hipUserObjectCreate,  // [411] HRR_API_HIPUSEROBJECTCREATE
    playback_hipUserObjectRelease,  // [412] HRR_API_HIPUSEROBJECTRELEASE
    playback_hipUserObjectRetain,  // [413] HRR_API_HIPUSEROBJECTRETAIN
    playback_hipWaitExternalSemaphoresAsync,  // [414] HRR_API_HIPWAITEXTERNALSEMAPHORESASYNC
    playback_hipMemcpy_spt,  // [415] HRR_API_HIPMEMCPY_SPT
    playback_hipMemcpyToSymbol_spt,  // [416] HRR_API_HIPMEMCPYTOSYMBOL_SPT
    playback_hipMemcpyFromSymbol_spt,  // [417] HRR_API_HIPMEMCPYFROMSYMBOL_SPT
    playback_hipMemcpy2D_spt,  // [418] HRR_API_HIPMEMCPY2D_SPT
    playback_hipMemcpy2DFromArray_spt,  // [419] HRR_API_HIPMEMCPY2DFROMARRAY_SPT
    playback_hipMemcpy3D_spt,  // [420] HRR_API_HIPMEMCPY3D_SPT
    playback_hipMemset_spt,  // [421] HRR_API_HIPMEMSET_SPT
    playback_hipMemsetAsync_spt,  // [422] HRR_API_HIPMEMSETASYNC_SPT
    playback_hipMemset2D_spt,  // [423] HRR_API_HIPMEMSET2D_SPT
    playback_hipMemset2DAsync_spt,  // [424] HRR_API_HIPMEMSET2DASYNC_SPT
    playback_hipMemset3DAsync_spt,  // [425] HRR_API_HIPMEMSET3DASYNC_SPT
    playback_hipMemset3D_spt,  // [426] HRR_API_HIPMEMSET3D_SPT
    playback_hipMemcpyAsync_spt,  // [427] HRR_API_HIPMEMCPYASYNC_SPT
    playback_hipMemcpy3DAsync_spt,  // [428] HRR_API_HIPMEMCPY3DASYNC_SPT
    playback_hipMemcpy2DAsync_spt,  // [429] HRR_API_HIPMEMCPY2DASYNC_SPT
    playback_hipMemcpyFromSymbolAsync_spt,  // [430] HRR_API_HIPMEMCPYFROMSYMBOLASYNC_SPT
    playback_hipMemcpyToSymbolAsync_spt,  // [431] HRR_API_HIPMEMCPYTOSYMBOLASYNC_SPT
    playback_hipMemcpyFromArray_spt,  // [432] HRR_API_HIPMEMCPYFROMARRAY_SPT
    playback_hipMemcpy2DToArray_spt,  // [433] HRR_API_HIPMEMCPY2DTOARRAY_SPT
    playback_hipMemcpy2DFromArrayAsync_spt,  // [434] HRR_API_HIPMEMCPY2DFROMARRAYASYNC_SPT
    playback_hipMemcpy2DToArrayAsync_spt,  // [435] HRR_API_HIPMEMCPY2DTOARRAYASYNC_SPT
    playback_hipStreamQuery_spt,  // [436] HRR_API_HIPSTREAMQUERY_SPT
    playback_hipStreamSynchronize_spt,  // [437] HRR_API_HIPSTREAMSYNCHRONIZE_SPT
    playback_hipStreamGetPriority_spt,  // [438] HRR_API_HIPSTREAMGETPRIORITY_SPT
    playback_hipStreamWaitEvent_spt,  // [439] HRR_API_HIPSTREAMWAITEVENT_SPT
    playback_hipStreamGetFlags_spt,  // [440] HRR_API_HIPSTREAMGETFLAGS_SPT
    playback_hipStreamAddCallback_spt,  // [441] HRR_API_HIPSTREAMADDCALLBACK_SPT
    playback_hipEventRecord_spt,  // [442] HRR_API_HIPEVENTRECORD_SPT
    playback_hipLaunchCooperativeKernel_spt,  // [443] HRR_API_HIPLAUNCHCOOPERATIVEKERNEL_SPT
    playback_hipLaunchKernel_spt,  // [444] HRR_API_HIPLAUNCHKERNEL_SPT
    playback_hipGraphLaunch_spt,  // [445] HRR_API_HIPGRAPHLAUNCH_SPT
    playback_hipStreamBeginCapture_spt,  // [446] HRR_API_HIPSTREAMBEGINCAPTURE_SPT
    playback_hipStreamEndCapture_spt,  // [447] HRR_API_HIPSTREAMENDCAPTURE_SPT
    playback_hipStreamIsCapturing_spt,  // [448] HRR_API_HIPSTREAMISCAPTURING_SPT
    playback_hipStreamGetCaptureInfo_spt,  // [449] HRR_API_HIPSTREAMGETCAPTUREINFO_SPT
    playback_hipStreamGetCaptureInfo_v2_spt,  // [450] HRR_API_HIPSTREAMGETCAPTUREINFO_V2_SPT
    playback_hipLaunchHostFunc_spt,  // [451] HRR_API_HIPLAUNCHHOSTFUNC_SPT
    playback_hipCreateChannelDesc,  // [452] HRR_API_HIPCREATECHANNELDESC
    playback_hipExtModuleLaunchKernel,  // [453] HRR_API_HIPEXTMODULELAUNCHKERNEL
    playback_hipHccModuleLaunchKernel,  // [454] HRR_API_HIPHCCMODULELAUNCHKERNEL
    playback_hipGetStreamDeviceId,  // [455] HRR_API_HIPGETSTREAMDEVICEID
    playback_hipDrvGraphAddMemsetNode,  // [456] HRR_API_HIPDRVGRAPHADDMEMSETNODE
    playback_hipGraphAddExternalSemaphoresWaitNode,  // [457] HRR_API_HIPGRAPHADDEXTERNALSEMAPHORESWAITNODE
    playback_hipGraphAddExternalSemaphoresSignalNode,  // [458] HRR_API_HIPGRAPHADDEXTERNALSEMAPHORESSIGNALNODE
    playback_hipGraphExternalSemaphoresSignalNodeSetParams,  // [459] HRR_API_HIPGRAPHEXTERNALSEMAPHORESSIGNALNODESETPARAMS
    playback_hipGraphExternalSemaphoresWaitNodeSetParams,  // [460] HRR_API_HIPGRAPHEXTERNALSEMAPHORESWAITNODESETPARAMS
    playback_hipGraphExternalSemaphoresSignalNodeGetParams,  // [461] HRR_API_HIPGRAPHEXTERNALSEMAPHORESSIGNALNODEGETPARAMS
    playback_hipGraphExternalSemaphoresWaitNodeGetParams,  // [462] HRR_API_HIPGRAPHEXTERNALSEMAPHORESWAITNODEGETPARAMS
    playback_hipGraphExecExternalSemaphoresSignalNodeSetParams,  // [463] HRR_API_HIPGRAPHEXECEXTERNALSEMAPHORESSIGNALNODESETPARAMS
    playback_hipGraphExecExternalSemaphoresWaitNodeSetParams,  // [464] HRR_API_HIPGRAPHEXECEXTERNALSEMAPHORESWAITNODESETPARAMS
    playback_hipGraphAddNode,  // [465] HRR_API_HIPGRAPHADDNODE
    playback_hipGraphInstantiateWithParams,  // [466] HRR_API_HIPGRAPHINSTANTIATEWITHPARAMS
    playback_hipExtGetLastError,  // [467] HRR_API_HIPEXTGETLASTERROR
    playback_hipTexRefGetBorderColor,  // [468] HRR_API_HIPTEXREFGETBORDERCOLOR
    playback_hipTexRefGetArray,  // [469] HRR_API_HIPTEXREFGETARRAY
    playback_hipGetProcAddress,  // [470] HRR_API_HIPGETPROCADDRESS
    playback_hipStreamBeginCaptureToGraph,  // [471] HRR_API_HIPSTREAMBEGINCAPTURETOGRAPH
    playback_hipGetFuncBySymbol,  // [472] HRR_API_HIPGETFUNCBYSYMBOL
    playback_hipDrvGraphAddMemFreeNode,  // [473] HRR_API_HIPDRVGRAPHADDMEMFREENODE
    playback_hipDrvGraphExecMemcpyNodeSetParams,  // [474] HRR_API_HIPDRVGRAPHEXECMEMCPYNODESETPARAMS
    playback_hipDrvGraphExecMemsetNodeSetParams,  // [475] HRR_API_HIPDRVGRAPHEXECMEMSETNODESETPARAMS
    playback_hipSetValidDevices,  // [476] HRR_API_HIPSETVALIDDEVICES
    playback_hipMemcpyAtoD,  // [477] HRR_API_HIPMEMCPYATOD
    playback_hipMemcpyDtoA,  // [478] HRR_API_HIPMEMCPYDTOA
    playback_hipMemcpyAtoA,  // [479] HRR_API_HIPMEMCPYATOA
    playback_hipMemcpyAtoHAsync,  // [480] HRR_API_HIPMEMCPYATOHASYNC
    playback_hipMemcpyHtoAAsync,  // [481] HRR_API_HIPMEMCPYHTOAASYNC
    playback_hipMemcpy2DArrayToArray,  // [482] HRR_API_HIPMEMCPY2DARRAYTOARRAY
    playback_hipGraphExecGetFlags,  // [483] HRR_API_HIPGRAPHEXECGETFLAGS
    playback_hipGraphNodeSetParams,  // [484] HRR_API_HIPGRAPHNODESETPARAMS
    playback_hipGraphExecNodeSetParams,  // [485] HRR_API_HIPGRAPHEXECNODESETPARAMS
    playback_hipExternalMemoryGetMappedMipmappedArray,  // [486] HRR_API_HIPEXTERNALMEMORYGETMAPPEDMIPMAPPEDARRAY
    playback_hipDrvGraphMemcpyNodeGetParams,  // [487] HRR_API_HIPDRVGRAPHMEMCPYNODEGETPARAMS
    playback_hipDrvGraphMemcpyNodeSetParams,  // [488] HRR_API_HIPDRVGRAPHMEMCPYNODESETPARAMS
    playback_hipExtHostAlloc,  // [489] HRR_API_HIPEXTHOSTALLOC
    playback_hipDeviceGetTexture1DLinearMaxWidth,  // [490] HRR_API_HIPDEVICEGETTEXTURE1DLINEARMAXWIDTH
    playback_hipGraphAddBatchMemOpNode,  // [491] HRR_API_HIPGRAPHADDBATCHMEMOPNODE
    playback_hipGraphBatchMemOpNodeGetParams,  // [492] HRR_API_HIPGRAPHBATCHMEMOPNODEGETPARAMS
    playback_hipGraphBatchMemOpNodeSetParams,  // [493] HRR_API_HIPGRAPHBATCHMEMOPNODESETPARAMS
    playback_hipGraphExecBatchMemOpNodeSetParams,  // [494] HRR_API_HIPGRAPHEXECBATCHMEMOPNODESETPARAMS
    playback_hipEventRecordWithFlags,  // [495] HRR_API_HIPEVENTRECORDWITHFLAGS
    playback_hipLaunchKernelExC,  // [496] HRR_API_HIPLAUNCHKERNELEXC
    playback_hipDrvLaunchKernelEx,  // [497] HRR_API_HIPDRVLAUNCHKERNELEX
    playback_hipMemGetHandleForAddressRange,  // [498] HRR_API_HIPMEMGETHANDLEFORADDRESSRANGE
    playback_hipMemsetD2D8,  // [499] HRR_API_HIPMEMSETD2D8
    playback_hipMemsetD2D8Async,  // [500] HRR_API_HIPMEMSETD2D8ASYNC
    playback_hipMemsetD2D16,  // [501] HRR_API_HIPMEMSETD2D16
    playback_hipMemsetD2D16Async,  // [502] HRR_API_HIPMEMSETD2D16ASYNC
    playback_hipMemsetD2D32,  // [503] HRR_API_HIPMEMSETD2D32
    playback_hipMemsetD2D32Async,  // [504] HRR_API_HIPMEMSETD2D32ASYNC
    playback_hipStreamSetAttribute,  // [505] HRR_API_HIPSTREAMSETATTRIBUTE
    playback_hipStreamGetAttribute,  // [506] HRR_API_HIPSTREAMGETATTRIBUTE
    playback_hipModuleLoadFatBinary,  // [507] HRR_API_HIPMODULELOADFATBINARY
    playback_hipMemcpyBatchAsync,  // [508] HRR_API_HIPMEMCPYBATCHASYNC
    playback_hipMemcpy3DBatchAsync,  // [509] HRR_API_HIPMEMCPY3DBATCHASYNC
    playback_hipMemcpy3DPeer,  // [510] HRR_API_HIPMEMCPY3DPEER
    playback_hipMemcpy3DPeerAsync,  // [511] HRR_API_HIPMEMCPY3DPEERASYNC
    playback_hipGetDriverEntryPoint,  // [512] HRR_API_HIPGETDRIVERENTRYPOINT
    playback_hipGetDriverEntryPoint_spt,  // [513] HRR_API_HIPGETDRIVERENTRYPOINT_SPT
    playback_hipLibraryLoadData,  // [514] HRR_API_HIPLIBRARYLOADDATA
    playback_hipLibraryLoadFromFile,  // [515] HRR_API_HIPLIBRARYLOADFROMFILE
    playback_hipLibraryUnload,  // [516] HRR_API_HIPLIBRARYUNLOAD
    playback_hipLibraryGetKernel,  // [517] HRR_API_HIPLIBRARYGETKERNEL
    playback_hipLibraryGetKernelCount,  // [518] HRR_API_HIPLIBRARYGETKERNELCOUNT
    playback_hipLibraryGetGlobal,  // [519] HRR_API_HIPLIBRARYGETGLOBAL
    playback_hipLibraryGetManaged,  // [520] HRR_API_HIPLIBRARYGETMANAGED
    playback_hipLibraryEnumerateKernels,  // [521] HRR_API_HIPLIBRARYENUMERATEKERNELS
    playback_hipKernelGetLibrary,  // [522] HRR_API_HIPKERNELGETLIBRARY
    playback_hipKernelGetName,  // [523] HRR_API_HIPKERNELGETNAME
    playback_hipGetProcAddress_spt,  // [524] HRR_API_HIPGETPROCADDRESS_SPT
    playback_hipExtDisableLogging,  // [525] HRR_API_HIPEXTDISABLELOGGING
    playback_hipExtEnableLogging,  // [526] HRR_API_HIPEXTENABLELOGGING
    playback_hipExtSetLoggingParams,  // [527] HRR_API_HIPEXTSETLOGGINGPARAMS
    playback_hipKernelGetAttribute,  // [528] HRR_API_HIPKERNELGETATTRIBUTE
    playback_hipKernelSetAttribute,  // [529] HRR_API_HIPKERNELSETATTRIBUTE
    playback_hipKernelGetFunction,  // [530] HRR_API_HIPKERNELGETFUNCTION
    playback_hipKernelGetParamInfo,  // [531] HRR_API_HIPKERNELGETPARAMINFO
    playback_hipMemSetMemPool,  // [532] HRR_API_HIPMEMSETMEMPOOL
    playback_hipMemGetMemPool,  // [533] HRR_API_HIPMEMGETMEMPOOL
    playback_hipMipmappedArrayGetMemoryRequirements,  // [534] HRR_API_HIPMIPMAPPEDARRAYGETMEMORYREQUIREMENTS
    playback_hipGreenCtxCreate,  // [535] HRR_API_HIPGREENCTXCREATE
    playback_hipExecutionCtxDestroy,  // [536] HRR_API_HIPEXECUTIONCTXDESTROY
    playback_hipExecutionCtxStreamCreate,  // [537] HRR_API_HIPEXECUTIONCTXSTREAMCREATE
    playback_hipDeviceGetDevResource,  // [538] HRR_API_HIPDEVICEGETDEVRESOURCE
    playback_hipDevSmResourceSplitByCount,  // [539] HRR_API_HIPDEVSMRESOURCESPLITBYCOUNT
    playback_hipDevSmResourceSplit,  // [540] HRR_API_HIPDEVSMRESOURCESPLIT
    playback_hipDevResourceGenerateDesc,  // [541] HRR_API_HIPDEVRESOURCEGENERATEDESC
    playback_hipDeviceGetExecutionCtx,  // [542] HRR_API_HIPDEVICEGETEXECUTIONCTX
    playback_hipExecutionCtxGetDevResource,  // [543] HRR_API_HIPEXECUTIONCTXGETDEVRESOURCE
    playback_hipExecutionCtxGetDevice,  // [544] HRR_API_HIPEXECUTIONCTXGETDEVICE
    playback_hipExecutionCtxGetId,  // [545] HRR_API_HIPEXECUTIONCTXGETID
    playback_hipStreamGetDevResource,  // [546] HRR_API_HIPSTREAMGETDEVRESOURCE
    playback_hipExecutionCtxRecordEvent,  // [547] HRR_API_HIPEXECUTIONCTXRECORDEVENT
    playback_hipExecutionCtxSynchronize,  // [548] HRR_API_HIPEXECUTIONCTXSYNCHRONIZE
    playback_hipExecutionCtxWaitEvent,  // [549] HRR_API_HIPEXECUTIONCTXWAITEVENT
};
