gozel/api.go

// Code generated by cmd/gen. DO NOT EDIT.

/*
 *
 * Copyright (C) 2026 Fumiama Minamoto
 *
 * SPDX-License-Identifier: MIT
 *
 * @file api.go
 *
 */

package gozel

import (
	"fmt"
	"os"

	"github.com/fumiama/gozel/internal/zecall"
)

const debug = false

func init() {

	if err := zecall.Register("zeInit"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGet"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeInitDrivers"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetApiVersion"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetIpcProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetExtensionProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetExtensionFunctionAddress"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetLastErrorDescription"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverGetDefaultContext"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGet"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetRootDevice"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetSubDevices"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetComputeProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetModuleProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetCommandQueueGroupProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetMemoryProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetMemoryAccessProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetCacheProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetImageProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetExternalMemoryProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetP2PProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceCanAccessPeer"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetStatus"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetGlobalTimestamps"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceSynchronize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetAggregatedCopyOffloadIncrementValue"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextCreateEx"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextGetStatus"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandQueueCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandQueueDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandQueueExecuteCommandLists"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandQueueSynchronize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandQueueGetOrdinal"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandQueueGetIndex"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListCreateImmediate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListClose"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListReset"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendWriteGlobalTimestamp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListHostSynchronize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListGetDeviceHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListGetContextHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListGetOrdinal"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListImmediateGetIndex"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListIsImmediate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendBarrier"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemoryRangesBarrier"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextSystemBarrier"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemoryCopy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemoryFill"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemoryCopyRegion"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemoryCopyFromContext"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendImageCopy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendImageCopyRegion"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendImageCopyToMemory"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendImageCopyFromMemory"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemoryPrefetch"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendMemAdvise"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventCounterBasedCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolGetIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolPutIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolOpenIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolCloseIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventCounterBasedGetIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventCounterBasedOpenIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventCounterBasedCloseIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventCounterBasedGetDeviceAddress"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendSignalEvent"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendWaitOnEvents"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventHostSignal"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventHostSynchronize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventQueryStatus"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendEventReset"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventHostReset"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventQueryKernelTimestamp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendQueryKernelTimestamps"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventGetEventPool"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventGetSignalScope"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventGetWaitScope"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolGetContextHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventPoolGetFlags"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFenceCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFenceDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFenceHostSynchronize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFenceQueryStatus"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFenceReset"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemAllocShared"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemAllocDevice"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemAllocHost"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemFree"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetAllocProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetAddressRange"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetIpcHandleFromFileDescriptorExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetFileDescriptorFromIpcHandleExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemPutIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemOpenIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemCloseIpcHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemSetAtomicAccessAttributeExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetAtomicAccessAttributeExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleDynamicLink"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleBuildLogDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleBuildLogGetString"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleGetNativeBinary"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleGetGlobalPointer"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleGetKernelNames"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleGetFunctionPointer"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSetGroupSize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSuggestGroupSize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSuggestMaxCooperativeGroupCount"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSetArgumentValue"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSetIndirectAccess"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelGetIndirectAccess"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelGetSourceAttributes"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSetCacheConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelGetName"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendLaunchKernel"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendLaunchKernelWithParameters"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendLaunchKernelWithArguments"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendLaunchCooperativeKernel"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendLaunchKernelIndirect"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendLaunchMultipleKernelsIndirect"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextMakeMemoryResident"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextEvictMemory"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextMakeImageResident"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeContextEvictImage"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeSamplerCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeSamplerDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemReserve"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemFree"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemQueryPageSize"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zePhysicalMemGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zePhysicalMemCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zePhysicalMemDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemMap"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemUnmap"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemSetAccessAttribute"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeVirtualMemGetAccessAttribute"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSetGlobalOffsetExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelGetBinaryExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceImportExternalSemaphoreExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceReleaseExternalSemaphoreExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendSignalExternalSemaphoreExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendWaitExternalSemaphoreExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderCreateExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderGetBuildPropertiesExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverRTASFormatCompatibilityCheckExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderBuildExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderCommandListAppendCopyExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderDestroyExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationCreateExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationGetPropertiesExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationJoinExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationDestroyExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetVectorWidthPropertiesExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelGetAllocationPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetIpcHandleWithProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceReserveCacheExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceSetCacheAdviceExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventQueryTimestampsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageGetMemoryPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageViewCreateExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageViewCreateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeKernelSchedulingHintExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDevicePciGetPropertiesExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendImageCopyToMemoryExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListAppendImageCopyFromMemoryExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageGetAllocPropertiesExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeModuleInspectLinkageExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemFreeExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricVertexGetExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricVertexGetSubVerticesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricVertexGetPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricVertexGetDeviceExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDeviceGetFabricVertexExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricEdgeGetExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricEdgeGetVerticesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeFabricEdgeGetPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeEventQueryKernelTimestampsExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderCreateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderGetBuildPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeDriverRTASFormatCompatibilityCheckExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderBuildExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASBuilderDestroyExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationCreateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationGetPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationJoinExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeRTASParallelOperationDestroyExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeMemGetPitchFor2dImage"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeImageGetDeviceOffsetExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListCreateCloneExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListImmediateAppendCommandListsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListGetNextCommandIdExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListGetNextCommandIdWithKernelsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListUpdateMutableCommandsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListUpdateMutableCommandSignalEventExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListUpdateMutableCommandWaitEventsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zeCommandListUpdateMutableCommandKernelsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zerGetLastErrorDescription"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zerTranslateDeviceHandleToIdentifier"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zerTranslateIdentifierToDeviceHandle"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zerGetDefaultContext"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesInit"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDriverGet"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDriverGetExtensionProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDriverGetExtensionFunctionAddress"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGet"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceReset"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceResetExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceProcessesGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDevicePciGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDevicePciGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDevicePciGetBars"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDevicePciGetStats"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceSetOverclockWaiver"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetOverclockDomains"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetOverclockControls"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceResetOverclockSettings"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceReadOverclockState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumOverclockDomains"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetDomainProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetDomainVFProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetDomainControlProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetControlCurrentValue"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetControlPendingValue"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockSetControlUserValue"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetControlState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockGetVFPointValues"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesOverclockSetVFPointValues"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumDiagnosticTestSuites"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDiagnosticsGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDiagnosticsGetTests"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDiagnosticsRunTests"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEccAvailable"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEccConfigurable"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetEccState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceSetEccState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumEngineGroups"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesEngineGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesEngineGetActivity"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEventRegister"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDriverEventListen"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDriverEventListenEx"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumFabricPorts"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetLinkType"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortSetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetThroughput"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetFabricErrorCounters"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFabricPortGetMultiPortThroughput"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumFans"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFanGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFanGetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFanSetDefaultMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFanSetFixedSpeedMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFanSetSpeedTableMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFanGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumFirmwares"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFirmwareGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFirmwareFlash"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFirmwareGetFlashProgress"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFirmwareGetConsoleLogs"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumFrequencyDomains"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyGetAvailableClocks"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyGetRange"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencySetRange"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyGetThrottleTime"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcGetCapabilities"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcGetFrequencyTarget"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcSetFrequencyTarget"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcGetVoltageTarget"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcSetVoltageTarget"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcSetMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcGetMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcGetIccMax"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcSetIccMax"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcGetTjMax"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFrequencyOcSetTjMax"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumLeds"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesLedGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesLedGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesLedSetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesLedSetColor"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumMemoryModules"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesMemoryGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesMemoryGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesMemoryGetBandwidth"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumPerformanceFactorDomains"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPerformanceFactorGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPerformanceFactorGetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPerformanceFactorSetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumPowerDomains"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetCardPowerDomain"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerGetEnergyCounter"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerGetLimits"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerSetLimits"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerGetEnergyThreshold"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerSetEnergyThreshold"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumPsus"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPsuGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPsuGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumRasErrorSets"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesRasGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesRasGetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesRasSetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesRasGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumSchedulers"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerGetCurrentMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerGetTimeoutModeProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerGetTimesliceModeProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerSetTimeoutMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerSetTimesliceMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerSetExclusiveMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesSchedulerSetComputeUnitDebugMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumStandbyDomains"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesStandbyGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesStandbyGetMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesStandbySetMode"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumTemperatureSensors"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesTemperatureGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesTemperatureGetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesTemperatureSetConfig"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesTemperatureGetState"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDevicePciLinkSpeedUpdateExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerGetLimitsExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesPowerSetLimitsExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesEngineGetActivityExt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesRasGetStateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesRasClearStateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFirmwareGetSecurityVersionExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesFirmwareSetSecurityVersionExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceGetSubDevicePropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDriverGetDeviceByUuidExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumActiveVFExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFMemoryUtilizationExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFEngineUtilizationExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementSetVFTelemetryModeExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementSetVFTelemetrySamplingIntervalExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesDeviceEnumEnabledVFExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFCapabilitiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFMemoryUtilizationExp2"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFEngineUtilizationExp2"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zesVFManagementGetVFCapabilitiesExp2"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetModuleGetDebugInfo"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDeviceGetDebugProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugAttach"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugDetach"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugReadEvent"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugAcknowledgeEvent"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugInterrupt"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugResume"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugReadMemory"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugWriteMemory"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugGetRegisterSetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugGetThreadRegisterSetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugReadRegisters"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDebugWriteRegisters"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupGet"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupCalculateMetricValues"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGet"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGetProperties"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetContextActivateMetricGroups"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricStreamerOpen"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetCommandListAppendMetricStreamerMarker"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricStreamerClose"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricStreamerReadData"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricQueryPoolCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricQueryPoolDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricQueryCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricQueryDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricQueryReset"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetCommandListAppendMetricQueryBegin"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetCommandListAppendMetricQueryEnd"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetCommandListAppendMetricMemoryBarrier"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricQueryGetData"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetKernelGetProfileInfo"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetTracerExpCreate"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetTracerExpDestroy"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetTracerExpSetPrologues"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetTracerExpSetEpilogues"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetTracerExpSetEnabled"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDeviceGetConcurrentMetricGroupsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricTracerCreateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricTracerDestroyExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricTracerEnableExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricTracerDisableExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricTracerReadDataExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricDecoderCreateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricDecoderDestroyExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricDecoderGetDecodableMetricsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricTracerDecodeExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetCommandListAppendMarkerExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDeviceEnableMetricsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDeviceDisableMetricsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupCalculateMultipleMetricValuesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupGetGlobalTimestampsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupGetExportDataExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupCalculateMetricExportDataExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricProgrammableGetExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricProgrammableGetPropertiesExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricProgrammableGetParamInfoExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricProgrammableGetParamValueInfoExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricCreateFromProgrammableExp2"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricCreateFromProgrammableExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetDeviceCreateMetricGroupsFromMetricsExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupCreateExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupAddMetricExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupRemoveMetricExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupCloseExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricGroupDestroyExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

	if err := zecall.Register("zetMetricDestroyExp"); debug && err != nil {
		fmt.Fprintln(os.Stderr, "[gozel.warn]", err)
	}

}