cc/gapii/gles_exports.cpp

/*
 * Copyright 2015, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * THIS FILE WAS GENERATED BY apic. DO NOT EDIT.
 */


#include "gles_exports.h"
#include "gles_imports.h"
#include "gles_types.h"
#include "spy.h"

#include <gapic/get_gfx_proc_address.h>
#include <gapic/log.h>
#include <gapic/target.h> // STDCALL

#include <memory>

#include <string.h>

using namespace gapii;

extern "C" {
EXPORT void STDCALL glBlendBarrierKHR();
EXPORT void STDCALL glBlendEquationSeparateiEXT(DrawBufferIndex buf, uint32_t modeRGB, uint32_t modeAlpha);
EXPORT void STDCALL glBlendEquationiEXT(DrawBufferIndex buf, uint32_t mode);
EXPORT void STDCALL glBlendFuncSeparateiEXT(DrawBufferIndex buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha);
EXPORT void STDCALL glBlendFunciEXT(DrawBufferIndex buf, uint32_t src, uint32_t dst);
EXPORT void STDCALL glColorMaskiEXT(DrawBufferIndex index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
EXPORT void STDCALL glCopyImageSubDataEXT(GLuint srcName, uint32_t srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, uint32_t dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
EXPORT void STDCALL glDebugMessageCallbackKHR(GLDEBUGPROC callback, void* userParam);
EXPORT void STDCALL glDebugMessageControlKHR(uint32_t source, uint32_t type, uint32_t severity, GLsizei count, GLuint* ids, GLboolean enabled);
EXPORT void STDCALL glDebugMessageInsertKHR(uint32_t source, uint32_t type, GLuint id, uint32_t severity, GLsizei length, GLchar* message);
EXPORT void STDCALL glDisableiEXT(uint32_t target, GLuint index);
EXPORT void STDCALL glEnableiEXT(uint32_t target, GLuint index);
EXPORT void STDCALL glFramebufferTextureEXT(uint32_t target, uint32_t attachment, TextureId texture, GLint level);
EXPORT GLuint STDCALL glGetDebugMessageLogKHR(GLuint count, GLsizei bufSize, uint32_t* sources, uint32_t* types, GLuint* ids, uint32_t* severities, GLsizei* lengths, GLchar* messageLog);
EXPORT void STDCALL glGetObjectLabelKHR(uint32_t identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label);
EXPORT void STDCALL glGetObjectPtrLabelKHR(void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label);
EXPORT void STDCALL glGetPointervKHR(uint32_t pname, void** params);
EXPORT void STDCALL glGetSamplerParameterIivEXT(SamplerId sampler, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetSamplerParameterIuivEXT(SamplerId sampler, uint32_t pname, GLuint* params);
EXPORT void STDCALL glGetTexParameterIivEXT(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexParameterIuivEXT(uint32_t target, uint32_t pname, GLuint* params);
EXPORT GLboolean STDCALL glIsEnablediEXT(uint32_t target, GLuint index);
EXPORT void STDCALL glMinSampleShadingOES(GLfloat value);
EXPORT void STDCALL glObjectLabelKHR(uint32_t identifier, GLuint name, GLsizei length, GLchar* label);
EXPORT void STDCALL glObjectPtrLabelKHR(void* ptr, GLsizei length, GLchar* label);
EXPORT void STDCALL glPatchParameteriEXT(uint32_t pname, GLint value);
EXPORT void STDCALL glPopDebugGroupKHR();
EXPORT void STDCALL glPrimitiveBoundingBoxEXT(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);
EXPORT void STDCALL glPushDebugGroupKHR(uint32_t source, GLuint id, GLsizei length, GLchar* message);
EXPORT void STDCALL glSamplerParameterIivEXT(SamplerId sampler, uint32_t pname, GLint* param);
EXPORT void STDCALL glSamplerParameterIuivEXT(SamplerId sampler, uint32_t pname, GLuint* param);
EXPORT void STDCALL glTexBufferEXT(uint32_t target, uint32_t internalformat, BufferId buffer);
EXPORT void STDCALL glTexBufferRangeEXT(uint32_t target, uint32_t internalformat, BufferId buffer, GLintptr offset, GLsizeiptr size);
EXPORT void STDCALL glTexParameterIivEXT(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glTexParameterIuivEXT(uint32_t target, uint32_t pname, GLuint* params);
EXPORT void STDCALL glTexStorage3DMultisampleOES(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
EXPORT void STDCALL glBeginQuery(uint32_t target, QueryId query);
EXPORT void STDCALL glDeleteQueries(GLsizei count, QueryId* queries);
EXPORT void STDCALL glEndQuery(uint32_t target);
EXPORT void STDCALL glGenQueries(GLsizei count, QueryId* queries);
EXPORT void STDCALL glGetQueryObjectuiv(QueryId query, uint32_t parameter, GLuint* value);
EXPORT void STDCALL glGetQueryiv(uint32_t target, uint32_t parameter, GLint* value);
EXPORT GLboolean STDCALL glIsQuery(QueryId query);
EXPORT void STDCALL glBindBuffer(uint32_t target, BufferId buffer);
EXPORT void STDCALL glBindBufferBase(uint32_t target, GLuint index, BufferId buffer);
EXPORT void STDCALL glBindBufferRange(uint32_t target, GLuint index, BufferId buffer, GLintptr offset, GLsizeiptr size);
EXPORT void STDCALL glBufferData(uint32_t target, GLsizeiptr size, BufferDataPointer data, uint32_t usage);
EXPORT void STDCALL glBufferSubData(uint32_t target, GLintptr offset, GLsizeiptr size, BufferDataPointer data);
EXPORT void STDCALL glCopyBufferSubData(uint32_t readTarget, uint32_t writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
EXPORT void STDCALL glDeleteBuffers(GLsizei count, BufferId* buffers);
EXPORT void STDCALL glGenBuffers(GLsizei count, BufferId* buffers);
EXPORT void STDCALL glGetBufferParameteri64v(uint32_t target, uint32_t parameter, GLint64* value);
EXPORT void STDCALL glGetBufferParameteriv(uint32_t target, uint32_t parameter, GLint* value);
EXPORT void STDCALL glGetBufferPointerv(uint32_t target, uint32_t pname, void** params);
EXPORT GLboolean STDCALL glIsBuffer(BufferId buffer);
EXPORT void* STDCALL glMapBufferRange(uint32_t target, GLintptr offset, GLsizeiptr length, uint32_t access);
EXPORT GLboolean STDCALL glUnmapBuffer(uint32_t target);
EXPORT void STDCALL glDebugMessageCallback(GLDEBUGPROC callback, void* userParam);
EXPORT void STDCALL glDebugMessageControl(uint32_t source, uint32_t type, uint32_t severity, GLsizei count, GLuint* ids, GLboolean enabled);
EXPORT void STDCALL glDebugMessageInsert(uint32_t source, uint32_t type, GLuint id, uint32_t severity, GLsizei length, GLchar* message);
EXPORT GLuint STDCALL glGetDebugMessageLog(GLuint count, GLsizei bufSize, uint32_t* sources, uint32_t* types, GLuint* ids, uint32_t* severities, GLsizei* lengths, GLchar* messageLog);
EXPORT void STDCALL glGetObjectLabel(uint32_t identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label);
EXPORT void STDCALL glGetObjectPtrLabel(void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label);
EXPORT void STDCALL glGetPointerv(uint32_t pname, void** params);
EXPORT void STDCALL glObjectLabel(uint32_t identifier, GLuint name, GLsizei length, GLchar* label);
EXPORT void STDCALL glObjectPtrLabel(void* ptr, GLsizei length, GLchar* label);
EXPORT void STDCALL glPopDebugGroup();
EXPORT void STDCALL glPushDebugGroup(uint32_t source, GLuint id, GLsizei length, GLchar* message);
EXPORT void STDCALL glDrawArrays(uint32_t draw_mode, GLint first_index, GLsizei indices_count);
EXPORT void STDCALL glDrawArraysIndirect(uint32_t draw_mode, void* indirect);
EXPORT void STDCALL glDrawArraysInstanced(uint32_t draw_mode, GLint first_index, GLsizei indices_count, GLsizei instance_count);
EXPORT void STDCALL glDrawElements(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices);
EXPORT void STDCALL glDrawElementsBaseVertex(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLint base_vertex);
EXPORT void STDCALL glDrawElementsIndirect(uint32_t draw_mode, uint32_t indices_type, void* indirect);
EXPORT void STDCALL glDrawElementsInstanced(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLsizei instance_count);
EXPORT void STDCALL glDrawElementsInstancedBaseVertex(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLsizei instance_count, GLint base_vertex);
EXPORT void STDCALL glDrawRangeElements(uint32_t draw_mode, GLuint start, GLuint end, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices);
EXPORT void STDCALL glDrawRangeElementsBaseVertex(uint32_t draw_mode, GLuint start, GLuint end, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLint base_vertex);
EXPORT void STDCALL glPatchParameteri(uint32_t pname, GLint value);
EXPORT void STDCALL glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);
EXPORT void STDCALL glActiveShaderProgramEXT(PipelineId pipeline, ProgramId program);
EXPORT void STDCALL glAlphaFuncQCOM(uint32_t func, GLclampf ref);
EXPORT void STDCALL glApplyFramebufferAttachmentCMAAINTEL();
EXPORT void STDCALL glBeginConditionalRenderNV(GLuint id, uint32_t mode);
EXPORT void STDCALL glBeginPerfMonitorAMD(GLuint monitor);
EXPORT void STDCALL glBeginPerfQueryINTEL(GLuint queryHandle);
EXPORT void STDCALL glBeginQueryEXT(uint32_t target, QueryId query);
EXPORT void STDCALL glBindFragDataLocationEXT(ProgramId program, GLuint color, const char* name);
EXPORT void STDCALL glBindFragDataLocationIndexedEXT(ProgramId program, GLuint colorNumber, GLuint index, const char* name);
EXPORT void STDCALL glBindProgramPipelineEXT(PipelineId pipeline);
EXPORT void STDCALL glBindVertexArrayOES(VertexArrayId array);
EXPORT void STDCALL glBlendBarrierNV();
EXPORT void STDCALL glBlendEquationSeparateiOES(DrawBufferIndex buf, uint32_t modeRGB, uint32_t modeAlpha);
EXPORT void STDCALL glBlendEquationiOES(DrawBufferIndex buf, uint32_t mode);
EXPORT void STDCALL glBlendFuncSeparateiOES(DrawBufferIndex buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha);
EXPORT void STDCALL glBlendFunciOES(DrawBufferIndex buf, uint32_t src, uint32_t dst);
EXPORT void STDCALL glBlendParameteriNV(uint32_t pname, GLint value);
EXPORT void STDCALL glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, uint32_t mask, uint32_t filter);
EXPORT void STDCALL glBlitFramebufferNV(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, uint32_t mask, uint32_t filter);
EXPORT void STDCALL glBufferStorageEXT(uint32_t target, GLsizeiptr size, void* data, uint32_t flag);
EXPORT uint32_t STDCALL glClientWaitSyncAPPLE(GLsync sync, uint32_t flag, GLuint64 timeout);
EXPORT void STDCALL glColorMaskiOES(DrawBufferIndex index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
EXPORT void STDCALL glCompressedTexImage3DOES(uint32_t target, GLint level, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei image_size, TexturePointer data);
EXPORT void STDCALL glCompressedTexSubImage3DOES(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, GLsizei image_size, TexturePointer data);
EXPORT void STDCALL glCopyBufferSubDataNV(uint32_t readTarget, uint32_t writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
EXPORT void STDCALL glCopyImageSubDataOES(GLuint srcName, uint32_t srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, uint32_t dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
EXPORT void STDCALL glCopyPathNV(GLuint resultPath, GLuint srcPath);
EXPORT void STDCALL glCopyTexSubImage3DOES(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
EXPORT void STDCALL glCopyTextureLevelsAPPLE(GLuint destinationTexture, GLuint sourceTexture, GLint sourceBaseLevel, GLsizei sourceLevelCount);
EXPORT void STDCALL glCoverFillPathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glCoverFillPathNV(GLuint path, uint32_t coverMode);
EXPORT void STDCALL glCoverStrokePathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glCoverStrokePathNV(GLuint path, uint32_t coverMode);
EXPORT void STDCALL glCoverageMaskNV(GLboolean mask);
EXPORT void STDCALL glCoverageModulationNV(uint32_t components);
EXPORT void STDCALL glCoverageModulationTableNV(GLsizei n, GLfloat* v);
EXPORT void STDCALL glCoverageOperationNV(uint32_t operation);
EXPORT void STDCALL glCreatePerfQueryINTEL(GLuint queryId, GLuint* queryHandle);
EXPORT GLuint STDCALL glCreateShaderProgramvEXT(uint32_t type, GLsizei count, GLchar** strings);
EXPORT void STDCALL glDeleteFencesNV(GLsizei n, GLuint* fences);
EXPORT void STDCALL glDeletePathsNV(GLuint path, GLsizei range);
EXPORT void STDCALL glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors);
EXPORT void STDCALL glDeletePerfQueryINTEL(GLuint queryHandle);
EXPORT void STDCALL glDeleteProgramPipelinesEXT(GLsizei n, PipelineId* pipelines);
EXPORT void STDCALL glDeleteQueriesEXT(GLsizei count, QueryId* queries);
EXPORT void STDCALL glDeleteSyncAPPLE(GLsync sync);
EXPORT void STDCALL glDeleteVertexArraysOES(GLsizei count, VertexArrayId* arrays);
EXPORT void STDCALL glDepthRangeArrayfvNV(GLuint first, GLsizei count, GLfloat* v);
EXPORT void STDCALL glDepthRangeIndexedfNV(GLuint index, GLfloat n, GLfloat f);
EXPORT void STDCALL glDisableDriverControlQCOM(GLuint driverControl);
EXPORT void STDCALL glDisableiNV(uint32_t target, GLuint index);
EXPORT void STDCALL glDisableiOES(uint32_t target, GLuint index);
EXPORT void STDCALL glDiscardFramebufferEXT(uint32_t target, GLsizei numAttachments, uint32_t* attachments);
EXPORT void STDCALL glDrawArraysInstancedANGLE(uint32_t mode, GLint first, GLsizei count, GLsizei primcount);
EXPORT void STDCALL glDrawArraysInstancedBaseInstanceEXT(uint32_t mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
EXPORT void STDCALL glDrawArraysInstancedEXT(uint32_t mode, GLint start, GLsizei count, GLsizei primcount);
EXPORT void STDCALL glDrawArraysInstancedNV(uint32_t mode, GLint first, GLsizei count, GLsizei primcount);
EXPORT void STDCALL glDrawBuffersEXT(GLsizei n, uint32_t* bufs);
EXPORT void STDCALL glDrawBuffersIndexedEXT(GLint n, uint32_t* location, GLint* indices);
EXPORT void STDCALL glDrawBuffersNV(GLsizei n, uint32_t* bufs);
EXPORT void STDCALL glDrawElementsBaseVertexEXT(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex);
EXPORT void STDCALL glDrawElementsBaseVertexOES(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex);
EXPORT void STDCALL glDrawElementsInstancedANGLE(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei primcount);
EXPORT void STDCALL glDrawElementsInstancedBaseInstanceEXT(uint32_t mode, GLsizei count, uint32_t type, void* indices, GLsizei instancecount, GLuint baseinstance);
EXPORT void STDCALL glDrawElementsInstancedBaseVertexBaseInstanceEXT(uint32_t mode, GLsizei count, uint32_t type, void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
EXPORT void STDCALL glDrawElementsInstancedBaseVertexEXT(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei instancecount, GLint basevertex);
EXPORT void STDCALL glDrawElementsInstancedBaseVertexOES(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei instancecount, GLint basevertex);
EXPORT void STDCALL glDrawElementsInstancedEXT(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei primcount);
EXPORT void STDCALL glDrawElementsInstancedNV(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei primcount);
EXPORT void STDCALL glDrawRangeElementsBaseVertexEXT(uint32_t mode, GLuint start, GLuint end, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex);
EXPORT void STDCALL glDrawRangeElementsBaseVertexOES(uint32_t mode, GLuint start, GLuint end, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex);
EXPORT void STDCALL glEGLImageTargetRenderbufferStorageOES(uint32_t target, GLeglImageOES image);
EXPORT void STDCALL glEGLImageTargetTexture2DOES(uint32_t target, GLeglImageOES image);
EXPORT void STDCALL glEnableDriverControlQCOM(GLuint driverControl);
EXPORT void STDCALL glEnableiNV(uint32_t target, GLuint index);
EXPORT void STDCALL glEnableiOES(uint32_t target, GLuint index);
EXPORT void STDCALL glEndConditionalRenderNV();
EXPORT void STDCALL glEndPerfMonitorAMD(GLuint monitor);
EXPORT void STDCALL glEndPerfQueryINTEL(GLuint queryHandle);
EXPORT void STDCALL glEndQueryEXT(uint32_t target);
EXPORT void STDCALL glEndTilingQCOM(uint32_t preserve_mask);
EXPORT void STDCALL glExtGetBufferPointervQCOM(uint32_t target, void** params);
EXPORT void STDCALL glExtGetBuffersQCOM(BufferId* buffers, GLint maxBuffers, GLint* numBuffers);
EXPORT void STDCALL glExtGetFramebuffersQCOM(FramebufferId* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);
EXPORT void STDCALL glExtGetProgramBinarySourceQCOM(ProgramId program, uint32_t shadertype, GLchar* source, GLint* length);
EXPORT void STDCALL glExtGetProgramsQCOM(ProgramId* programs, GLint maxPrograms, GLint* numPrograms);
EXPORT void STDCALL glExtGetRenderbuffersQCOM(RenderbufferId* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);
EXPORT void STDCALL glExtGetShadersQCOM(ShaderId* shaders, GLint maxShaders, GLint* numShaders);
EXPORT void STDCALL glExtGetTexLevelParameterivQCOM(TextureId texture, uint32_t face, GLint level, uint32_t pname, GLint* params);
EXPORT void STDCALL glExtGetTexSubImageQCOM(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, void* texels);
EXPORT void STDCALL glExtGetTexturesQCOM(TextureId* textures, GLint maxTextures, GLint* numTextures);
EXPORT GLboolean STDCALL glExtIsProgramBinaryQCOM(ProgramId program);
EXPORT void STDCALL glExtTexObjectStateOverrideiQCOM(uint32_t target, uint32_t pname, GLint param);
EXPORT GLsync STDCALL glFenceSyncAPPLE(uint32_t condition, uint32_t flag);
EXPORT void STDCALL glFinishFenceNV(GLuint fence);
EXPORT void STDCALL glFlushMappedBufferRangeEXT(uint32_t target, GLintptr offset, GLsizeiptr length);
EXPORT void STDCALL glFragmentCoverageColorNV(GLuint color);
EXPORT void STDCALL glFramebufferSampleLocationsfvNV(uint32_t target, GLuint start, GLsizei count, GLfloat* v);
EXPORT void STDCALL glFramebufferTexture2DMultisampleEXT(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level, GLsizei samples);
EXPORT void STDCALL glFramebufferTexture2DMultisampleIMG(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level, GLsizei samples);
EXPORT void STDCALL glFramebufferTexture3DOES(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level, GLint zoffset);
EXPORT void STDCALL glFramebufferTextureMultiviewOVR(uint32_t target, uint32_t attachment, TextureId texture, GLint level, GLint baseViewIndex, GLsizei numViews);
EXPORT void STDCALL glFramebufferTextureOES(uint32_t target, uint32_t attachment, TextureId texture, GLint level);
EXPORT void STDCALL glGenFencesNV(GLsizei n, GLuint* fences);
EXPORT GLuint STDCALL glGenPathsNV(GLsizei range);
EXPORT void STDCALL glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors);
EXPORT void STDCALL glGenProgramPipelinesEXT(GLsizei n, PipelineId* pipelines);
EXPORT void STDCALL glGenQueriesEXT(GLsizei count, QueryId* queries);
EXPORT void STDCALL glGenVertexArraysOES(GLsizei count, VertexArrayId* arrays);
EXPORT void STDCALL glGetBufferPointervOES(uint32_t target, uint32_t pname, void** params);
EXPORT void STDCALL glGetCoverageModulationTableNV(GLsizei bufsize, GLfloat* v);
EXPORT void STDCALL glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString);
EXPORT void STDCALL glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls);
EXPORT void STDCALL glGetFenceivNV(GLuint fence, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetFirstPerfQueryIdINTEL(GLuint* queryId);
EXPORT void STDCALL glGetFloati_vNV(uint32_t target, GLuint index, GLfloat* data);
EXPORT GLint STDCALL glGetFragDataIndexEXT(ProgramId program, const char* name);
EXPORT uint32_t STDCALL glGetGraphicsResetStatusEXT();
EXPORT uint32_t STDCALL glGetGraphicsResetStatusKHR();
EXPORT GLuint64 STDCALL glGetImageHandleNV(TextureId texture, GLint level, GLboolean layered, GLint layer, uint32_t format);
EXPORT void STDCALL glGetInteger64vAPPLE(uint32_t pname, GLint64* params);
EXPORT void STDCALL glGetIntegeri_vEXT(uint32_t target, GLuint index, GLint* data);
EXPORT void STDCALL glGetInternalformatSampleivNV(uint32_t target, uint32_t internalformat, GLsizei samples, uint32_t pname, GLsizei bufSize, GLint* params);
EXPORT void STDCALL glGetNextPerfQueryIdINTEL(GLuint queryId, GLuint* nextQueryId);
EXPORT void STDCALL glGetObjectLabelEXT(uint32_t type, GLuint object, GLsizei bufSize, GLsizei* length, GLchar* label);
EXPORT void STDCALL glGetPathCommandsNV(GLuint path, GLubyte* commands);
EXPORT void STDCALL glGetPathCoordsNV(GLuint path, GLfloat* coords);
EXPORT void STDCALL glGetPathDashArrayNV(GLuint path, GLfloat* dashArray);
EXPORT GLfloat STDCALL glGetPathLengthNV(GLuint path, GLsizei startSegment, GLsizei numSegments);
EXPORT void STDCALL glGetPathMetricRangeNV(uint32_t metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics);
EXPORT void STDCALL glGetPathMetricsNV(uint32_t metricQueryMask, GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics);
EXPORT void STDCALL glGetPathParameterfvNV(GLuint path, uint32_t pname, GLfloat* value);
EXPORT void STDCALL glGetPathParameterivNV(GLuint path, uint32_t pname, GLint* value);
EXPORT void STDCALL glGetPathSpacingNV(uint32_t pathListMode, GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, uint32_t transformType, GLfloat* returnedSpacing);
EXPORT void STDCALL glGetPerfCounterInfoINTEL(GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar* counterName, GLuint counterDescLength, GLchar* counterDesc, GLuint* counterOffset, GLuint* counterDataSize, GLuint* counterTypeEnum, GLuint* counterDataTypeEnum, GLuint64* rawCounterMaxValue);
EXPORT void STDCALL glGetPerfMonitorCounterDataAMD(GLuint monitor, uint32_t pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten);
EXPORT void STDCALL glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, uint32_t pname, void* data);
EXPORT void STDCALL glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString);
EXPORT void STDCALL glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters);
EXPORT void STDCALL glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString);
EXPORT void STDCALL glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups);
EXPORT void STDCALL glGetPerfQueryDataINTEL(GLuint queryHandle, GLuint flag, GLsizei dataSize, GLvoid* data, GLuint* bytesWritten);
EXPORT void STDCALL glGetPerfQueryIdByNameINTEL(GLchar* queryName, GLuint* queryId);
EXPORT void STDCALL glGetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, GLchar* queryName, GLuint* dataSize, GLuint* noCounters, GLuint* noInstances, GLuint* capsMask);
EXPORT void STDCALL glGetProgramBinaryOES(ProgramId program, GLsizei buffer_size, GLsizei* bytes_written, uint32_t* binary_format, void* binary);
EXPORT void STDCALL glGetProgramPipelineInfoLogEXT(PipelineId pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
EXPORT void STDCALL glGetProgramPipelineivEXT(PipelineId pipeline, uint32_t pname, GLint* params);
EXPORT GLint STDCALL glGetProgramResourceLocationIndexEXT(ProgramId program, uint32_t programInterface, const char* name);
EXPORT void STDCALL glGetProgramResourcefvNV(ProgramId program, uint32_t programInterface, GLuint index, GLsizei propCount, uint32_t* props, GLsizei bufSize, GLsizei* length, GLfloat* params);
EXPORT void STDCALL glGetQueryObjecti64vEXT(QueryId query, uint32_t parameter, GLint64* value);
EXPORT void STDCALL glGetQueryObjectivEXT(QueryId query, uint32_t parameter, GLint* value);
EXPORT void STDCALL glGetQueryObjectui64vEXT(QueryId query, uint32_t parameter, GLuint64* value);
EXPORT void STDCALL glGetQueryObjectuivEXT(QueryId query, uint32_t parameter, GLuint* value);
EXPORT void STDCALL glGetQueryivEXT(uint32_t target, uint32_t parameter, GLint* value);
EXPORT void STDCALL glGetSamplerParameterIivOES(SamplerId sampler, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetSamplerParameterIuivOES(SamplerId sampler, uint32_t pname, GLuint* params);
EXPORT void STDCALL glGetSyncivAPPLE(GLsync sync, uint32_t pname, GLsizei bufSize, GLsizei* length, GLint* values);
EXPORT void STDCALL glGetTexParameterIivOES(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexParameterIuivOES(uint32_t target, uint32_t pname, GLuint* params);
EXPORT GLuint64 STDCALL glGetTextureHandleNV(TextureId texture);
EXPORT GLuint64 STDCALL glGetTextureSamplerHandleNV(TextureId texture, SamplerId sampler);
EXPORT void STDCALL glGetTranslatedShaderSourceANGLE(ShaderId shader, GLsizei bufsize, GLsizei* length, GLchar* source);
EXPORT void STDCALL glGetnUniformfvEXT(ProgramId program, UniformLocation location, GLsizei bufSize, GLfloat* params);
EXPORT void STDCALL glGetnUniformfvKHR(ProgramId program, UniformLocation location, GLsizei bufSize, GLfloat* params);
EXPORT void STDCALL glGetnUniformivEXT(ProgramId program, UniformLocation location, GLsizei bufSize, GLint* params);
EXPORT void STDCALL glGetnUniformivKHR(ProgramId program, UniformLocation location, GLsizei bufSize, GLint* params);
EXPORT void STDCALL glGetnUniformuivKHR(ProgramId program, UniformLocation location, GLsizei bufSize, GLuint* params);
EXPORT void STDCALL glInsertEventMarkerEXT(GLsizei length, GLchar* marker);
EXPORT void STDCALL glInterpolatePathsNV(GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight);
EXPORT GLboolean STDCALL glIsEnablediNV(uint32_t target, GLuint index);
EXPORT GLboolean STDCALL glIsEnablediOES(uint32_t target, GLuint index);
EXPORT GLboolean STDCALL glIsFenceNV(GLuint fence);
EXPORT GLboolean STDCALL glIsImageHandleResidentNV(GLuint64 handle);
EXPORT GLboolean STDCALL glIsPathNV(GLuint path);
EXPORT GLboolean STDCALL glIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y);
EXPORT GLboolean STDCALL glIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y);
EXPORT GLboolean STDCALL glIsProgramPipelineEXT(PipelineId pipeline);
EXPORT GLboolean STDCALL glIsQueryEXT(QueryId query);
EXPORT GLboolean STDCALL glIsSyncAPPLE(GLsync sync);
EXPORT GLboolean STDCALL glIsTextureHandleResidentNV(GLuint64 handle);
EXPORT GLboolean STDCALL glIsVertexArrayOES(VertexArrayId array);
EXPORT void STDCALL glLabelObjectEXT(uint32_t type, GLuint object, GLsizei length, GLchar* label);
EXPORT void STDCALL glMakeImageHandleNonResidentNV(GLuint64 handle);
EXPORT void STDCALL glMakeImageHandleResidentNV(GLuint64 handle, uint32_t access);
EXPORT void STDCALL glMakeTextureHandleNonResidentNV(GLuint64 handle);
EXPORT void STDCALL glMakeTextureHandleResidentNV(GLuint64 handle);
EXPORT void* STDCALL glMapBufferOES(uint32_t target, uint32_t access);
EXPORT void* STDCALL glMapBufferRangeEXT(uint32_t target, GLintptr offset, GLsizeiptr length, uint32_t access);
EXPORT void STDCALL glMatrixLoad3x2fNV(uint32_t matrixMode, GLfloat* m);
EXPORT void STDCALL glMatrixLoad3x3fNV(uint32_t matrixMode, GLfloat* m);
EXPORT void STDCALL glMatrixLoadTranspose3x3fNV(uint32_t matrixMode, GLfloat* m);
EXPORT void STDCALL glMatrixMult3x2fNV(uint32_t matrixMode, GLfloat* m);
EXPORT void STDCALL glMatrixMult3x3fNV(uint32_t matrixMode, GLfloat* m);
EXPORT void STDCALL glMatrixMultTranspose3x3fNV(uint32_t matrixMode, GLfloat* m);
EXPORT void STDCALL glMultiDrawArraysEXT(uint32_t mode, GLint* first, GLsizei* count, GLsizei primcount);
EXPORT void STDCALL glMultiDrawArraysIndirectEXT(uint32_t mode, void* indirect, GLsizei drawcount, GLsizei stride);
EXPORT void STDCALL glMultiDrawElementsBaseVertexEXT(uint32_t mode, GLsizei* count, uint32_t type, void** indices, GLsizei primcount, GLint* basevertex);
EXPORT void STDCALL glMultiDrawElementsBaseVertexOES(uint32_t mode, GLsizei* count, uint32_t type, void** indices, GLsizei primcount, GLint* basevertex);
EXPORT void STDCALL glMultiDrawElementsEXT(uint32_t mode, GLsizei* count, uint32_t type, void** indices, GLsizei primcount);
EXPORT void STDCALL glMultiDrawElementsIndirectEXT(uint32_t mode, uint32_t type, void* indirect, GLsizei drawcount, GLsizei stride);
EXPORT void STDCALL glNamedFramebufferSampleLocationsfvNV(FramebufferId framebuffer, GLuint start, GLsizei count, GLfloat* v);
EXPORT void STDCALL glPatchParameteriOES(uint32_t pname, GLint value);
EXPORT void STDCALL glPathCommandsNV(GLuint path, GLsizei numCommands, GLubyte* commands, GLsizei numCoords, uint32_t coordType, void* coords);
EXPORT void STDCALL glPathCoordsNV(GLuint path, GLsizei numCoords, uint32_t coordType, void* coords);
EXPORT void STDCALL glPathCoverDepthFuncNV(uint32_t func);
EXPORT void STDCALL glPathDashArrayNV(GLuint path, GLsizei dashCount, GLfloat* dashArray);
EXPORT uint32_t STDCALL glPathGlyphIndexArrayNV(GLuint firstPathName, uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
EXPORT uint32_t STDCALL glPathGlyphIndexRangeNV(uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount);
EXPORT void STDCALL glPathGlyphRangeNV(GLuint firstPathName, uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLuint firstGlyph, GLsizei numGlyphs, uint32_t handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
EXPORT void STDCALL glPathGlyphsNV(GLuint firstPathName, uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLsizei numGlyphs, uint32_t type, void* charcodes, uint32_t handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
EXPORT uint32_t STDCALL glPathMemoryGlyphIndexArrayNV(GLuint firstPathName, uint32_t fontTarget, GLsizeiptr fontSize, void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale);
EXPORT void STDCALL glPathParameterfNV(GLuint path, uint32_t pname, GLfloat value);
EXPORT void STDCALL glPathParameterfvNV(GLuint path, uint32_t pname, GLfloat* value);
EXPORT void STDCALL glPathParameteriNV(GLuint path, uint32_t pname, GLint value);
EXPORT void STDCALL glPathParameterivNV(GLuint path, uint32_t pname, GLint* value);
EXPORT void STDCALL glPathStencilDepthOffsetNV(GLfloat factor, GLfloat units);
EXPORT void STDCALL glPathStencilFuncNV(uint32_t func, GLint ref, GLuint mask);
EXPORT void STDCALL glPathStringNV(GLuint path, uint32_t format, GLsizei length, void* pathString);
EXPORT void STDCALL glPathSubCommandsNV(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, GLubyte* commands, GLsizei numCoords, uint32_t coordType, void* coords);
EXPORT void STDCALL glPathSubCoordsNV(GLuint path, GLsizei coordStart, GLsizei numCoords, uint32_t coordType, void* coords);
EXPORT GLboolean STDCALL glPointAlongPathNV(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY);
EXPORT void STDCALL glPolygonModeNV(uint32_t face, uint32_t mode);
EXPORT void STDCALL glPopGroupMarkerEXT();
EXPORT void STDCALL glPrimitiveBoundingBoxOES(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW);
EXPORT void STDCALL glProgramBinaryOES(ProgramId program, uint32_t binary_format, void* binary, GLint binary_size);
EXPORT void STDCALL glProgramParameteriEXT(ProgramId program, uint32_t pname, GLint value);
EXPORT void STDCALL glProgramPathFragmentInputGenNV(ProgramId program, GLint location, uint32_t genMode, GLint components, GLfloat* coeffs);
EXPORT void STDCALL glProgramUniform1fEXT(ProgramId program, UniformLocation location, GLfloat v0);
EXPORT void STDCALL glProgramUniform1fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value);
EXPORT void STDCALL glProgramUniform1iEXT(ProgramId program, UniformLocation location, GLint v0);
EXPORT void STDCALL glProgramUniform1ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value);
EXPORT void STDCALL glProgramUniform1uiEXT(ProgramId program, UniformLocation location, GLuint v0);
EXPORT void STDCALL glProgramUniform1uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value);
EXPORT void STDCALL glProgramUniform2fEXT(ProgramId program, UniformLocation location, GLfloat v0, GLfloat v1);
EXPORT void STDCALL glProgramUniform2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value);
EXPORT void STDCALL glProgramUniform2iEXT(ProgramId program, UniformLocation location, GLint v0, GLint v1);
EXPORT void STDCALL glProgramUniform2ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value);
EXPORT void STDCALL glProgramUniform2uiEXT(ProgramId program, UniformLocation location, GLuint v0, GLuint v1);
EXPORT void STDCALL glProgramUniform2uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value);
EXPORT void STDCALL glProgramUniform3fEXT(ProgramId program, UniformLocation location, GLfloat v0, GLfloat v1, GLfloat v2);
EXPORT void STDCALL glProgramUniform3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value);
EXPORT void STDCALL glProgramUniform3iEXT(ProgramId program, UniformLocation location, GLint v0, GLint v1, GLint v2);
EXPORT void STDCALL glProgramUniform3ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value);
EXPORT void STDCALL glProgramUniform3uiEXT(ProgramId program, UniformLocation location, GLuint v0, GLuint v1, GLuint v2);
EXPORT void STDCALL glProgramUniform3uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value);
EXPORT void STDCALL glProgramUniform4fEXT(ProgramId program, UniformLocation location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
EXPORT void STDCALL glProgramUniform4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value);
EXPORT void STDCALL glProgramUniform4iEXT(ProgramId program, UniformLocation location, GLint v0, GLint v1, GLint v2, GLint v3);
EXPORT void STDCALL glProgramUniform4ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value);
EXPORT void STDCALL glProgramUniform4uiEXT(ProgramId program, UniformLocation location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
EXPORT void STDCALL glProgramUniform4uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value);
EXPORT void STDCALL glProgramUniformHandleui64NV(ProgramId program, UniformLocation location, GLuint64 value);
EXPORT void STDCALL glProgramUniformHandleui64vNV(ProgramId program, UniformLocation location, GLsizei count, GLuint64* values);
EXPORT void STDCALL glProgramUniformMatrix2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix2x3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix2x4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix3x2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix3x4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix4x2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glProgramUniformMatrix4x3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glPushGroupMarkerEXT(GLsizei length, GLchar* marker);
EXPORT void STDCALL glQueryCounterEXT(QueryId query, uint32_t target);
EXPORT void STDCALL glRasterSamplesEXT(GLuint samples, GLboolean fixedsamplelocations);
EXPORT void STDCALL glReadBufferIndexedEXT(uint32_t src, GLint index);
EXPORT void STDCALL glReadBufferNV(uint32_t mode);
EXPORT void STDCALL glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, GLsizei bufSize, void* data);
EXPORT void STDCALL glReadnPixelsKHR(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, GLsizei bufSize, void* data);
EXPORT void STDCALL glRenderbufferStorageMultisampleANGLE(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glRenderbufferStorageMultisampleAPPLE(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glRenderbufferStorageMultisampleEXT(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glRenderbufferStorageMultisampleIMG(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glRenderbufferStorageMultisampleNV(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glResolveDepthValuesNV();
EXPORT void STDCALL glResolveMultisampleFramebufferAPPLE();
EXPORT void STDCALL glSamplerParameterIivOES(SamplerId sampler, uint32_t pname, GLint* param);
EXPORT void STDCALL glSamplerParameterIuivOES(SamplerId sampler, uint32_t pname, GLuint* param);
EXPORT void STDCALL glScissorArrayvNV(GLuint first, GLsizei count, GLint* v);
EXPORT void STDCALL glScissorIndexedNV(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
EXPORT void STDCALL glScissorIndexedvNV(GLuint index, GLint* v);
EXPORT void STDCALL glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList);
EXPORT void STDCALL glSetFenceNV(GLuint fence, uint32_t condition);
EXPORT void STDCALL glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, uint32_t preserveMask);
EXPORT void STDCALL glStencilFillPathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t fillMode, GLuint mask, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glStencilFillPathNV(GLuint path, uint32_t fillMode, GLuint mask);
EXPORT void STDCALL glStencilStrokePathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLint reference, GLuint mask, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glStencilStrokePathNV(GLuint path, GLint reference, GLuint mask);
EXPORT void STDCALL glStencilThenCoverFillPathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t fillMode, GLuint mask, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glStencilThenCoverFillPathNV(GLuint path, uint32_t fillMode, GLuint mask, uint32_t coverMode);
EXPORT void STDCALL glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLint reference, GLuint mask, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glStencilThenCoverStrokePathNV(GLuint path, GLint reference, GLuint mask, uint32_t coverMode);
EXPORT void STDCALL glSubpixelPrecisionBiasNV(GLuint xbits, GLuint ybits);
EXPORT GLboolean STDCALL glTestFenceNV(GLuint fence);
EXPORT void STDCALL glTexBufferOES(uint32_t target, uint32_t internalformat, BufferId buffer);
EXPORT void STDCALL glTexBufferRangeOES(uint32_t target, uint32_t internalformat, BufferId buffer, GLintptr offset, GLsizeiptr size);
EXPORT void STDCALL glTexImage3DOES(uint32_t target, GLint level, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, uint32_t format, uint32_t type, TexturePointer pixels);
EXPORT void STDCALL glTexPageCommitmentEXT(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit);
EXPORT void STDCALL glTexParameterIivOES(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glTexParameterIuivOES(uint32_t target, uint32_t pname, GLuint* params);
EXPORT void STDCALL glTexStorage1DEXT(uint32_t target, GLsizei levels, uint32_t format, GLsizei width);
EXPORT void STDCALL glTexStorage2DEXT(uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height);
EXPORT void STDCALL glTexStorage3DEXT(uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height, GLsizei depth);
EXPORT void STDCALL glTexSubImage3DOES(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, TexturePointer pixels);
EXPORT void STDCALL glTextureStorage1DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t format, GLsizei width);
EXPORT void STDCALL glTextureStorage2DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height);
EXPORT void STDCALL glTextureStorage3DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height, GLsizei depth);
EXPORT void STDCALL glTextureViewEXT(TextureId texture, uint32_t target, GLuint origtexture, uint32_t internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
EXPORT void STDCALL glTextureViewOES(TextureId texture, uint32_t target, GLuint origtexture, uint32_t internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
EXPORT void STDCALL glTransformPathNV(GLuint resultPath, GLuint srcPath, uint32_t transformType, GLfloat* transformValues);
EXPORT void STDCALL glUniformHandleui64NV(UniformLocation location, GLuint64 value);
EXPORT void STDCALL glUniformHandleui64vNV(UniformLocation location, GLsizei count, GLuint64* value);
EXPORT void STDCALL glUniformMatrix2x3fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glUniformMatrix2x4fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glUniformMatrix3x2fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glUniformMatrix3x4fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glUniformMatrix4x2fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT void STDCALL glUniformMatrix4x3fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value);
EXPORT GLboolean STDCALL glUnmapBufferOES(uint32_t target);
EXPORT void STDCALL glUseProgramStagesEXT(PipelineId pipeline, uint32_t stages, ProgramId program);
EXPORT void STDCALL glValidateProgramPipelineEXT(PipelineId pipeline);
EXPORT void STDCALL glVertexAttribDivisorANGLE(AttributeLocation index, GLuint divisor);
EXPORT void STDCALL glVertexAttribDivisorEXT(AttributeLocation index, GLuint divisor);
EXPORT void STDCALL glVertexAttribDivisorNV(AttributeLocation index, GLuint divisor);
EXPORT void STDCALL glViewportArrayvNV(GLuint first, GLsizei count, GLfloat* v);
EXPORT void STDCALL glViewportIndexedfNV(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
EXPORT void STDCALL glViewportIndexedfvNV(GLuint index, GLfloat* v);
EXPORT void STDCALL glWaitSyncAPPLE(GLsync sync, uint32_t flag, GLuint64 timeout);
EXPORT void STDCALL glWeightPathsNV(GLuint resultPath, GLsizei numPaths, GLuint* paths, GLfloat* weights);
EXPORT void STDCALL glBlendBarrier();
EXPORT void STDCALL glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
EXPORT void STDCALL glBlendEquation(uint32_t equation);
EXPORT void STDCALL glBlendEquationSeparate(uint32_t rgb, uint32_t alpha);
EXPORT void STDCALL glBlendEquationSeparatei(DrawBufferIndex buf, uint32_t modeRGB, uint32_t modeAlpha);
EXPORT void STDCALL glBlendEquationi(DrawBufferIndex buf, uint32_t mode);
EXPORT void STDCALL glBlendFunc(uint32_t src_factor, uint32_t dst_factor);
EXPORT void STDCALL glBlendFuncSeparate(uint32_t src_factor_rgb, uint32_t dst_factor_rgb, uint32_t src_factor_alpha, uint32_t dst_factor_alpha);
EXPORT void STDCALL glBlendFuncSeparatei(DrawBufferIndex buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha);
EXPORT void STDCALL glBlendFunci(DrawBufferIndex buf, uint32_t src, uint32_t dst);
EXPORT void STDCALL glDepthFunc(uint32_t function);
EXPORT void STDCALL glSampleCoverage(GLfloat value, GLboolean invert);
EXPORT void STDCALL glSampleMaski(GLuint maskNumber, uint32_t mask);
EXPORT void STDCALL glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
EXPORT void STDCALL glStencilFunc(uint32_t func, GLint ref, GLuint mask);
EXPORT void STDCALL glStencilFuncSeparate(uint32_t face, uint32_t function, GLint reference_value, GLuint mask);
EXPORT void STDCALL glStencilOp(uint32_t fail, uint32_t zfail, uint32_t zpass);
EXPORT void STDCALL glStencilOpSeparate(uint32_t face, uint32_t stencil_fail, uint32_t stencil_pass_depth_fail, uint32_t stencil_pass_depth_pass);
EXPORT void STDCALL glBindFramebuffer(uint32_t target, FramebufferId framebuffer);
EXPORT void STDCALL glBindRenderbuffer(uint32_t target, RenderbufferId renderbuffer);
EXPORT void STDCALL glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, uint32_t mask, uint32_t filter);
EXPORT uint32_t STDCALL glCheckFramebufferStatus(uint32_t target);
EXPORT void STDCALL glClear(uint32_t mask);
EXPORT void STDCALL glClearBufferfi(uint32_t buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
EXPORT void STDCALL glClearBufferfv(uint32_t buffer, GLint drawbuffer, GLfloat* value);
EXPORT void STDCALL glClearBufferiv(uint32_t buffer, GLint drawbuffer, GLint* value);
EXPORT void STDCALL glClearBufferuiv(uint32_t buffer, GLint drawbuffer, GLuint* value);
EXPORT void STDCALL glClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a);
EXPORT void STDCALL glClearDepthf(GLfloat depth);
EXPORT void STDCALL glClearStencil(GLint stencil);
EXPORT void STDCALL glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
EXPORT void STDCALL glColorMaski(DrawBufferIndex index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
EXPORT void STDCALL glDeleteFramebuffers(GLsizei count, FramebufferId* framebuffers);
EXPORT void STDCALL glDeleteRenderbuffers(GLsizei count, RenderbufferId* renderbuffers);
EXPORT void STDCALL glDepthMask(GLboolean enabled);
EXPORT void STDCALL glDrawBuffers(GLsizei n, uint32_t* bufs);
EXPORT void STDCALL glFramebufferParameteri(uint32_t target, uint32_t pname, GLint param);
EXPORT void STDCALL glFramebufferRenderbuffer(uint32_t framebuffer_target, uint32_t framebuffer_attachment, uint32_t renderbuffer_target, RenderbufferId renderbuffer);
EXPORT void STDCALL glFramebufferTexture(uint32_t target, uint32_t attachment, TextureId texture, GLint level);
EXPORT void STDCALL glFramebufferTexture2D(uint32_t framebuffer_target, uint32_t framebuffer_attachment, uint32_t texture_target, TextureId texture, GLint level);
EXPORT void STDCALL glFramebufferTextureLayer(uint32_t target, uint32_t attachment, TextureId texture, GLint level, GLint layer);
EXPORT void STDCALL glGenFramebuffers(GLsizei count, FramebufferId* framebuffers);
EXPORT void STDCALL glGenRenderbuffers(GLsizei count, RenderbufferId* renderbuffers);
EXPORT void STDCALL glGetFramebufferAttachmentParameteriv(uint32_t framebuffer_target, uint32_t attachment, uint32_t parameter, GLint* value);
EXPORT void STDCALL glGetFramebufferParameteriv(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetRenderbufferParameteriv(uint32_t target, uint32_t parameter, GLint* values);
EXPORT void STDCALL glInvalidateFramebuffer(uint32_t target, GLsizei count, uint32_t* attachments);
EXPORT void STDCALL glInvalidateSubFramebuffer(uint32_t target, GLsizei numAttachments, uint32_t* attachments, GLint x, GLint y, GLsizei width, GLsizei height);
EXPORT GLboolean STDCALL glIsFramebuffer(FramebufferId framebuffer);
EXPORT GLboolean STDCALL glIsRenderbuffer(RenderbufferId renderbuffer);
EXPORT void STDCALL glReadBuffer(uint32_t src);
EXPORT void STDCALL glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, void* data);
EXPORT void STDCALL glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, GLsizei bufSize, void* data);
EXPORT void STDCALL glRenderbufferStorage(uint32_t target, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glRenderbufferStorageMultisample(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glStencilMask(GLuint mask);
EXPORT void STDCALL glStencilMaskSeparate(uint32_t face, GLuint mask);
EXPORT void STDCALL glDisable(uint32_t capability);
EXPORT void STDCALL glDisablei(uint32_t capability, GLuint index);
EXPORT void STDCALL glEnable(uint32_t capability);
EXPORT void STDCALL glEnablei(uint32_t capability, GLuint index);
EXPORT void STDCALL glFinish();
EXPORT void STDCALL glFlush();
EXPORT void STDCALL glFlushMappedBufferRange(uint32_t target, GLintptr offset, GLsizeiptr length);
EXPORT uint32_t STDCALL glGetError();
EXPORT uint32_t STDCALL glGetGraphicsResetStatus();
EXPORT void STDCALL glHint(uint32_t target, uint32_t mode);
EXPORT void STDCALL glActiveShaderProgram(PipelineId pipeline, ProgramId program);
EXPORT void STDCALL glAttachShader(ProgramId program, ShaderId shader);
EXPORT void STDCALL glBindAttribLocation(ProgramId program, AttributeLocation location, const char* name);
EXPORT void STDCALL glBindProgramPipeline(PipelineId pipeline);
EXPORT void STDCALL glCompileShader(ShaderId shader);
EXPORT ProgramId STDCALL glCreateProgram();
EXPORT ShaderId STDCALL glCreateShader(uint32_t type);
EXPORT ProgramId STDCALL glCreateShaderProgramv(uint32_t type, GLsizei count, GLchar** strings);
EXPORT void STDCALL glDeleteProgram(ProgramId program);
EXPORT void STDCALL glDeleteProgramPipelines(GLsizei n, PipelineId* pipelines);
EXPORT void STDCALL glDeleteShader(ShaderId shader);
EXPORT void STDCALL glDetachShader(ProgramId program, ShaderId shader);
EXPORT void STDCALL glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
EXPORT void STDCALL glDispatchComputeIndirect(GLintptr indirect);
EXPORT void STDCALL glGenProgramPipelines(GLsizei n, PipelineId* pipelines);
EXPORT void STDCALL glGetActiveAttrib(ProgramId program, AttributeIndex index, GLsizei buffer_size, GLsizei* buffer_bytes_written, GLint* vector_count, uint32_t* type, GLchar* name);
EXPORT void STDCALL glGetActiveUniform(ProgramId program, UniformIndex index, GLsizei buffer_size, GLsizei* buffer_bytes_written, GLint* vector_count, uint32_t* type, GLchar* name);
EXPORT void STDCALL glGetActiveUniformBlockName(ProgramId program, UniformBlockId uniform_block_index, GLsizei buffer_size, GLsizei* buffer_bytes_written, GLchar* name);
EXPORT void STDCALL glGetActiveUniformBlockiv(ProgramId program, UniformBlockId uniform_block_index, uint32_t parameter_name, GLint* parameters);
EXPORT void STDCALL glGetActiveUniformsiv(ProgramId program, GLsizei uniform_count, UniformIndex* uniform_indices, uint32_t parameter_name, GLint* parameters);
EXPORT void STDCALL glGetAttachedShaders(ProgramId program, GLsizei buffer_length, GLsizei* shaders_length_written, ShaderId* shaders);
EXPORT GLint STDCALL glGetAttribLocation(ProgramId program, const char* name);
EXPORT GLint STDCALL glGetFragDataLocation(ProgramId program, const char* name);
EXPORT void STDCALL glGetProgramBinary(ProgramId program, GLsizei bufSize, GLsizei* length, uint32_t* binaryFormat, void* binary);
EXPORT void STDCALL glGetProgramInfoLog(ProgramId program, GLsizei buffer_length, GLsizei* string_length_written, GLchar* info);
EXPORT void STDCALL glGetProgramInterfaceiv(ProgramId program, uint32_t programInterface, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetProgramPipelineInfoLog(PipelineId pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
EXPORT void STDCALL glGetProgramPipelineiv(PipelineId pipeline, uint32_t pname, GLint* params);
EXPORT GLuint STDCALL glGetProgramResourceIndex(ProgramId program, uint32_t programInterface, const char* name);
EXPORT GLint STDCALL glGetProgramResourceLocation(ProgramId program, uint32_t programInterface, const char* name);
EXPORT void STDCALL glGetProgramResourceName(ProgramId program, uint32_t programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name);
EXPORT void STDCALL glGetProgramResourceiv(ProgramId program, uint32_t programInterface, GLuint index, GLsizei propCount, uint32_t* props, GLsizei bufSize, GLsizei* length, GLint* params);
EXPORT void STDCALL glGetProgramiv(ProgramId program, uint32_t parameter, GLint* value);
EXPORT void STDCALL glGetShaderInfoLog(ShaderId shader, GLsizei buffer_length, GLsizei* string_length_written, GLchar* info);
EXPORT void STDCALL glGetShaderPrecisionFormat(uint32_t shader_type, uint32_t precision_type, GLint* range, GLint* precision);
EXPORT void STDCALL glGetShaderSource(ShaderId shader, GLsizei buffer_length, GLsizei* string_length_written, GLchar* source);
EXPORT void STDCALL glGetShaderiv(ShaderId shader, uint32_t parameter, GLint* value);
EXPORT UniformBlockId STDCALL glGetUniformBlockIndex(ProgramId program, const char* uniformBlockName);
EXPORT void STDCALL glGetUniformIndices(ProgramId program, GLsizei uniformCount, GLchar** uniformNames, UniformIndex* uniformIndices);
EXPORT UniformLocation STDCALL glGetUniformLocation(ProgramId program, const char* name);
EXPORT void STDCALL glGetUniformfv(ProgramId program, UniformLocation location, GLfloat* values);
EXPORT void STDCALL glGetUniformiv(ProgramId program, UniformLocation location, GLint* values);
EXPORT void STDCALL glGetUniformuiv(ProgramId program, UniformLocation location, GLuint* values);
EXPORT void STDCALL glGetnUniformfv(ProgramId program, UniformLocation location, GLsizei bufSize, GLfloat* values);
EXPORT void STDCALL glGetnUniformiv(ProgramId program, UniformLocation location, GLsizei bufSize, GLint* values);
EXPORT void STDCALL glGetnUniformuiv(ProgramId program, UniformLocation location, GLsizei bufSize, GLuint* values);
EXPORT GLboolean STDCALL glIsProgram(ProgramId program);
EXPORT GLboolean STDCALL glIsProgramPipeline(PipelineId pipeline);
EXPORT GLboolean STDCALL glIsShader(ShaderId shader);
EXPORT void STDCALL glLinkProgram(ProgramId program);
EXPORT void STDCALL glMemoryBarrier(uint32_t barriers);
EXPORT void STDCALL glMemoryBarrierByRegion(uint32_t barriers);
EXPORT void STDCALL glProgramBinary(ProgramId program, uint32_t binaryFormat, void* binary, GLsizei length);
EXPORT void STDCALL glProgramParameteri(ProgramId program, uint32_t pname, GLint value);
EXPORT void STDCALL glProgramUniform1f(ProgramId program, UniformLocation location, GLfloat value0);
EXPORT void STDCALL glProgramUniform1fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glProgramUniform1i(ProgramId program, UniformLocation location, GLint value0);
EXPORT void STDCALL glProgramUniform1iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glProgramUniform1ui(ProgramId program, UniformLocation location, GLuint value0);
EXPORT void STDCALL glProgramUniform1uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glProgramUniform2f(ProgramId program, UniformLocation location, GLfloat value0, GLfloat value1);
EXPORT void STDCALL glProgramUniform2fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glProgramUniform2i(ProgramId program, UniformLocation location, GLint value0, GLint value1);
EXPORT void STDCALL glProgramUniform2iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glProgramUniform2ui(ProgramId program, UniformLocation location, GLuint value0, GLuint value1);
EXPORT void STDCALL glProgramUniform2uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glProgramUniform3f(ProgramId program, UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2);
EXPORT void STDCALL glProgramUniform3fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glProgramUniform3i(ProgramId program, UniformLocation location, GLint value0, GLint value1, GLint value2);
EXPORT void STDCALL glProgramUniform3iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glProgramUniform3ui(ProgramId program, UniformLocation location, GLuint value0, GLuint value1, GLuint value2);
EXPORT void STDCALL glProgramUniform3uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glProgramUniform4f(ProgramId program, UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3);
EXPORT void STDCALL glProgramUniform4fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glProgramUniform4i(ProgramId program, UniformLocation location, GLint value0, GLint value1, GLint value2, GLint value3);
EXPORT void STDCALL glProgramUniform4iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glProgramUniform4ui(ProgramId program, UniformLocation location, GLuint value0, GLuint value1, GLuint value2, GLuint value3);
EXPORT void STDCALL glProgramUniform4uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glProgramUniformMatrix2fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix2x3fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix2x4fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix3fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix3x2fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix3x4fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix4fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix4x2fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glProgramUniformMatrix4x3fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glReleaseShaderCompiler();
EXPORT void STDCALL glShaderBinary(GLsizei count, ShaderId* shaders, uint32_t binary_format, void* binary, GLsizei binary_size);
EXPORT void STDCALL glShaderSource(ShaderId shader, GLsizei count, GLchar** source, GLint* length);
EXPORT void STDCALL glUniform1f(UniformLocation location, GLfloat value);
EXPORT void STDCALL glUniform1fv(UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glUniform1i(UniformLocation location, GLint value);
EXPORT void STDCALL glUniform1iv(UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glUniform1ui(UniformLocation location, GLuint value0);
EXPORT void STDCALL glUniform1uiv(UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glUniform2f(UniformLocation location, GLfloat value0, GLfloat value1);
EXPORT void STDCALL glUniform2fv(UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glUniform2i(UniformLocation location, GLint value0, GLint value1);
EXPORT void STDCALL glUniform2iv(UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glUniform2ui(UniformLocation location, GLuint value0, GLuint value1);
EXPORT void STDCALL glUniform2uiv(UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glUniform3f(UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2);
EXPORT void STDCALL glUniform3fv(UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glUniform3i(UniformLocation location, GLint value0, GLint value1, GLint value2);
EXPORT void STDCALL glUniform3iv(UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glUniform3ui(UniformLocation location, GLuint value0, GLuint value1, GLuint value2);
EXPORT void STDCALL glUniform3uiv(UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glUniform4f(UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3);
EXPORT void STDCALL glUniform4fv(UniformLocation location, GLsizei count, GLfloat* values);
EXPORT void STDCALL glUniform4i(UniformLocation location, GLint value0, GLint value1, GLint value2, GLint value3);
EXPORT void STDCALL glUniform4iv(UniformLocation location, GLsizei count, GLint* values);
EXPORT void STDCALL glUniform4ui(UniformLocation location, GLuint value0, GLuint value1, GLuint value2, GLuint value3);
EXPORT void STDCALL glUniform4uiv(UniformLocation location, GLsizei count, GLuint* values);
EXPORT void STDCALL glUniformBlockBinding(ProgramId program, UniformBlockId uniform_block_index, GLuint uniform_block_binding);
EXPORT void STDCALL glUniformMatrix2fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix2x3fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix2x4fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix3fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix3x2fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix3x4fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix4fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix4x2fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUniformMatrix4x3fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values);
EXPORT void STDCALL glUseProgram(ProgramId program);
EXPORT void STDCALL glUseProgramStages(PipelineId pipeline, uint32_t stages, ProgramId program);
EXPORT void STDCALL glValidateProgram(ProgramId program);
EXPORT void STDCALL glValidateProgramPipeline(PipelineId pipeline);
EXPORT void STDCALL glCullFace(uint32_t mode);
EXPORT void STDCALL glDepthRangef(GLfloat near, GLfloat far);
EXPORT void STDCALL glFrontFace(uint32_t orientation);
EXPORT void STDCALL glGetMultisamplefv(uint32_t pname, GLuint index, GLfloat* val);
EXPORT void STDCALL glLineWidth(GLfloat width);
EXPORT void STDCALL glMinSampleShading(GLfloat value);
EXPORT void STDCALL glPolygonOffset(GLfloat scale_factor, GLfloat units);
EXPORT void STDCALL glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
EXPORT void STDCALL glGetBooleani_v(uint32_t param, GLuint index, GLboolean* values);
EXPORT void STDCALL glGetBooleanv(uint32_t param, GLboolean* values);
EXPORT void STDCALL glGetFloatv(uint32_t param, GLfloat* values);
EXPORT void STDCALL glGetInteger64i_v(uint32_t param, GLuint index, GLint64* values);
EXPORT void STDCALL glGetInteger64v(uint32_t param, GLint64* values);
EXPORT void STDCALL glGetIntegeri_v(uint32_t param, GLuint index, GLint* values);
EXPORT void STDCALL glGetIntegerv(uint32_t param, GLint* values);
EXPORT void STDCALL glGetInternalformativ(uint32_t target, uint32_t internalformat, uint32_t pname, GLsizei bufSize, GLint* params);
EXPORT GLubyte* STDCALL glGetString(uint32_t param);
EXPORT GLubyte* STDCALL glGetStringi(uint32_t name, GLuint index);
EXPORT GLboolean STDCALL glIsEnabled(uint32_t capability);
EXPORT GLboolean STDCALL glIsEnabledi(uint32_t capability, GLuint index);
EXPORT uint32_t STDCALL glClientWaitSync(GLsync sync, uint32_t syncFlags, GLuint64 timeout);
EXPORT void STDCALL glDeleteSync(GLsync sync);
EXPORT GLsync STDCALL glFenceSync(uint32_t condition, uint32_t syncFlags);
EXPORT void STDCALL glGetSynciv(GLsync sync, uint32_t pname, GLsizei bufSize, GLsizei* length, GLint* values);
EXPORT GLboolean STDCALL glIsSync(GLsync sync);
EXPORT void STDCALL glWaitSync(GLsync sync, uint32_t syncFlags, GLuint64 timeout);
EXPORT void STDCALL glActiveTexture(uint32_t unit);
EXPORT void STDCALL glBindImageTexture(GLuint unit, TextureId texture, GLint level, GLboolean layered, GLint layer, uint32_t access, uint32_t format);
EXPORT void STDCALL glBindSampler(GLuint index, SamplerId sampler);
EXPORT void STDCALL glBindTexture(uint32_t target, TextureId texture);
EXPORT void STDCALL glCompressedTexImage2D(uint32_t target, GLint level, uint32_t format, GLsizei width, GLsizei height, GLint border, GLsizei image_size, TexturePointer data);
EXPORT void STDCALL glCompressedTexImage3D(uint32_t target, GLint level, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei image_size, TexturePointer data);
EXPORT void STDCALL glCompressedTexSubImage2D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, uint32_t format, GLsizei image_size, TexturePointer data);
EXPORT void STDCALL glCompressedTexSubImage3D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, GLsizei image_size, TexturePointer data);
EXPORT void STDCALL glCopyImageSubData(GLuint srcName, uint32_t srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, uint32_t dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
EXPORT void STDCALL glCopyTexImage2D(uint32_t target, GLint level, uint32_t format, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
EXPORT void STDCALL glCopyTexSubImage2D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
EXPORT void STDCALL glCopyTexSubImage3D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
EXPORT void STDCALL glDeleteSamplers(GLsizei count, SamplerId* samplers);
EXPORT void STDCALL glDeleteTextures(GLsizei count, TextureId* textures);
EXPORT void STDCALL glGenSamplers(GLsizei count, SamplerId* samplers);
EXPORT void STDCALL glGenTextures(GLsizei count, TextureId* textures);
EXPORT void STDCALL glGenerateMipmap(uint32_t target);
EXPORT void STDCALL glGetSamplerParameterIiv(SamplerId sampler, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetSamplerParameterIuiv(SamplerId sampler, uint32_t pname, GLuint* params);
EXPORT void STDCALL glGetSamplerParameterfv(SamplerId sampler, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetSamplerParameteriv(SamplerId sampler, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexLevelParameterfv(uint32_t target, GLint level, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetTexLevelParameteriv(uint32_t target, GLint level, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexParameterIiv(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexParameterIuiv(uint32_t target, uint32_t pname, GLuint* params);
EXPORT void STDCALL glGetTexParameterfv(uint32_t target, uint32_t parameter, GLfloat* values);
EXPORT void STDCALL glGetTexParameteriv(uint32_t target, uint32_t parameter, GLint* values);
EXPORT GLboolean STDCALL glIsSampler(SamplerId sampler);
EXPORT GLboolean STDCALL glIsTexture(TextureId texture);
EXPORT void STDCALL glPixelStorei(uint32_t parameter, GLint value);
EXPORT void STDCALL glSamplerParameterIiv(SamplerId sampler, uint32_t pname, GLint* param);
EXPORT void STDCALL glSamplerParameterIuiv(SamplerId sampler, uint32_t pname, GLuint* param);
EXPORT void STDCALL glSamplerParameterf(SamplerId sampler, uint32_t pname, GLfloat param);
EXPORT void STDCALL glSamplerParameterfv(SamplerId sampler, uint32_t pname, GLfloat* param);
EXPORT void STDCALL glSamplerParameteri(SamplerId sampler, uint32_t pname, GLint param);
EXPORT void STDCALL glSamplerParameteriv(SamplerId sampler, uint32_t pname, GLint* param);
EXPORT void STDCALL glTexBuffer(uint32_t target, uint32_t internalformat, BufferId buffer);
EXPORT void STDCALL glTexBufferRange(uint32_t target, uint32_t internalformat, BufferId buffer, GLintptr offset, GLsizeiptr size);
EXPORT void STDCALL glTexImage2D(uint32_t target, GLint level, GLint internal_format, GLsizei width, GLsizei height, GLint border, uint32_t format, uint32_t type, TexturePointer data);
EXPORT void STDCALL glTexImage3D(uint32_t target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, uint32_t format, uint32_t type, TexturePointer data);
EXPORT void STDCALL glTexParameterIiv(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glTexParameterIuiv(uint32_t target, uint32_t pname, GLuint* params);
EXPORT void STDCALL glTexParameterf(uint32_t target, uint32_t parameter, GLfloat value);
EXPORT void STDCALL glTexParameterfv(uint32_t target, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glTexParameteri(uint32_t target, uint32_t parameter, GLint value);
EXPORT void STDCALL glTexParameteriv(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glTexStorage2D(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glTexStorage2DMultisample(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
EXPORT void STDCALL glTexStorage3D(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth);
EXPORT void STDCALL glTexStorage3DMultisample(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
EXPORT void STDCALL glTexSubImage2D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, uint32_t format, uint32_t type, TexturePointer data);
EXPORT void STDCALL glTexSubImage3D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, TexturePointer data);
EXPORT void STDCALL glBeginTransformFeedback(uint32_t primitiveMode);
EXPORT void STDCALL glBindTransformFeedback(uint32_t target, TransformFeedbackId id);
EXPORT void STDCALL glDeleteTransformFeedbacks(GLsizei n, TransformFeedbackId* ids);
EXPORT void STDCALL glEndTransformFeedback();
EXPORT void STDCALL glGenTransformFeedbacks(GLsizei n, TransformFeedbackId* ids);
EXPORT void STDCALL glGetTransformFeedbackVarying(ProgramId program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, uint32_t* type, GLchar* name);
EXPORT GLboolean STDCALL glIsTransformFeedback(TransformFeedbackId id);
EXPORT void STDCALL glPauseTransformFeedback();
EXPORT void STDCALL glResumeTransformFeedback();
EXPORT void STDCALL glTransformFeedbackVaryings(ProgramId program, GLsizei count, GLchar** varyings, uint32_t bufferMode);
EXPORT void STDCALL glBindVertexArray(VertexArrayId array);
EXPORT void STDCALL glBindVertexBuffer(VertexBufferBindingIndex binding_index, BufferId buffer, GLintptr offset, GLsizei stride);
EXPORT void STDCALL glDeleteVertexArrays(GLsizei count, VertexArrayId* arrays);
EXPORT void STDCALL glDisableVertexAttribArray(AttributeLocation location);
EXPORT void STDCALL glEnableVertexAttribArray(AttributeLocation location);
EXPORT void STDCALL glGenVertexArrays(GLsizei count, VertexArrayId* arrays);
EXPORT void STDCALL glGetVertexAttribIiv(AttributeLocation index, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetVertexAttribIuiv(AttributeLocation index, uint32_t pname, GLuint* params);
EXPORT void STDCALL glGetVertexAttribPointerv(AttributeLocation index, uint32_t pname, void** pointer);
EXPORT void STDCALL glGetVertexAttribfv(AttributeLocation index, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetVertexAttribiv(AttributeLocation index, uint32_t pname, GLint* params);
EXPORT GLboolean STDCALL glIsVertexArray(VertexArrayId array);
EXPORT void STDCALL glVertexAttrib1f(AttributeLocation location, GLfloat value0);
EXPORT void STDCALL glVertexAttrib1fv(AttributeLocation location, GLfloat* value);
EXPORT void STDCALL glVertexAttrib2f(AttributeLocation location, GLfloat value0, GLfloat value1);
EXPORT void STDCALL glVertexAttrib2fv(AttributeLocation location, GLfloat* value);
EXPORT void STDCALL glVertexAttrib3f(AttributeLocation location, GLfloat value0, GLfloat value1, GLfloat value2);
EXPORT void STDCALL glVertexAttrib3fv(AttributeLocation location, GLfloat* value);
EXPORT void STDCALL glVertexAttrib4f(AttributeLocation location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3);
EXPORT void STDCALL glVertexAttrib4fv(AttributeLocation location, GLfloat* value);
EXPORT void STDCALL glVertexAttribBinding(AttributeLocation index, VertexBufferBindingIndex binding_index);
EXPORT void STDCALL glVertexAttribDivisor(AttributeLocation index, GLuint divisor);
EXPORT void STDCALL glVertexAttribFormat(AttributeLocation index, GLint size, uint32_t type, GLboolean normalized, GLuint relativeoffset);
EXPORT void STDCALL glVertexAttribI4i(AttributeLocation index, GLint x, GLint y, GLint z, GLint w);
EXPORT void STDCALL glVertexAttribI4iv(AttributeLocation index, GLint* values);
EXPORT void STDCALL glVertexAttribI4ui(AttributeLocation index, GLuint x, GLuint y, GLuint z, GLuint w);
EXPORT void STDCALL glVertexAttribI4uiv(AttributeLocation index, GLuint* values);
EXPORT void STDCALL glVertexAttribIFormat(AttributeLocation index, GLint size, uint32_t type, GLuint relativeoffset);
EXPORT void STDCALL glVertexAttribIPointer(AttributeLocation location, GLint size, uint32_t type, GLsizei stride, VertexPointer data);
EXPORT void STDCALL glVertexAttribPointer(AttributeLocation location, GLint size, uint32_t type, GLboolean normalized, GLsizei stride, VertexPointer data);
EXPORT void STDCALL glVertexBindingDivisor(VertexBufferBindingIndex binding_index, GLuint divisor);
EXPORT EGLBoolean STDCALL eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor);
EXPORT EGLContext STDCALL eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, EGLint* attrib_list);
EXPORT EGLBoolean STDCALL eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);
EXPORT EGLBoolean STDCALL eglSwapBuffers(EGLDisplay display, void* surface);
EXPORT EGLBoolean STDCALL eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects, EGLint n_rects);
EXPORT EGLBoolean STDCALL eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value);
EXPORT EGLBoolean STDCALL eglQueryContext(EGLDisplay display, EGLContext context, EGLint attribute, EGLint* value);
EXPORT EGLBoolean STDCALL eglChooseConfig(EGLDisplay display, EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
EXPORT EGLBoolean STDCALL eglGetConfigAttrib(EGLDisplay display, EGLConfig config, EGLint attribute, EGLint* value);
EXPORT GLXContext STDCALL glXCreateContext(void* dpy, void* vis, GLXContext shareList, bool direct);
EXPORT GLXContext STDCALL glXCreateNewContext(void* display, void* fbconfig, uint32_t type, GLXContext shared, bool direct);
EXPORT Bool STDCALL glXMakeContextCurrent(void* display, GLXDrawable draw, GLXDrawable read, GLXContext ctx);
EXPORT Bool STDCALL glXMakeCurrent(void* display, GLXDrawable drawable, GLXContext ctx);
EXPORT void STDCALL glXSwapBuffers(void* display, GLXDrawable drawable);
EXPORT int STDCALL glXQueryDrawable(void* display, GLXDrawable draw, int attribute, int* value);
EXPORT HGLRC STDCALL wglCreateContext(HDC hdc);
EXPORT HGLRC STDCALL wglCreateContextAttribsARB(HDC hdc, HGLRC hShareContext, int* attribList);
EXPORT BOOL STDCALL wglMakeCurrent(HDC hdc, HGLRC hglrc);
EXPORT void STDCALL wglSwapBuffers(HDC hdc);
EXPORT CGLError STDCALL CGLCreateContext(CGLTexelFormatObj pix, CGLContextObj share, CGLContextObj* ctx);
EXPORT CGLError STDCALL CGLSetCurrentContext(CGLContextObj ctx);
EXPORT int STDCALL CGLGetSurface(CGLContextObj ctx, CGSConnectionID* cid, CGSWindowID* wid, CGSSurfaceID* sid);
EXPORT int STDCALL CGSGetSurfaceBounds(CGSConnectionID cid, CGSWindowID wid, CGSSurfaceID sid, double* bounds);
EXPORT CGLError STDCALL CGLFlushDrawable(CGLContextObj ctx);
EXPORT void STDCALL glGetQueryObjecti64v(QueryId query, uint32_t parameter, int64_t* value);
EXPORT void STDCALL glGetQueryObjectui64v(QueryId query, uint32_t parameter, uint64_t* value);
EXPORT void STDCALL glAlphaFunc(uint32_t func, GLfloat ref);
EXPORT void STDCALL glAlphaFuncx(uint32_t func, GLfixed ref);
EXPORT void STDCALL glAlphaFuncxOES(uint32_t func, GLfixed ref);
EXPORT void STDCALL glBindFramebufferOES(uint32_t target, GLuint framebuffer);
EXPORT void STDCALL glBindRenderbufferOES(uint32_t target, GLuint renderbuffer);
EXPORT void STDCALL glBlendEquationOES(uint32_t mode);
EXPORT void STDCALL glBlendEquationSeparateOES(uint32_t modeRGB, uint32_t modeAlpha);
EXPORT void STDCALL glBlendFuncSeparateOES(uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha);
EXPORT uint32_t STDCALL glCheckFramebufferStatusOES(uint32_t target);
EXPORT void STDCALL glClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
EXPORT void STDCALL glClearColorxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
EXPORT void STDCALL glClearDepthfOES(GLclampf depth);
EXPORT void STDCALL glClearDepthx(GLfixed depth);
EXPORT void STDCALL glClearDepthxOES(GLfixed depth);
EXPORT void STDCALL glClientActiveTexture(uint32_t texture);
EXPORT void STDCALL glClipPlanef(uint32_t p, GLfloat* eqn);
EXPORT void STDCALL glClipPlanefIMG(uint32_t p, GLfloat* eqn);
EXPORT void STDCALL glClipPlanefOES(uint32_t plane, GLfloat* equation);
EXPORT void STDCALL glClipPlanex(uint32_t plane, GLfixed* equation);
EXPORT void STDCALL glClipPlanexIMG(uint32_t p, GLfixed* eqn);
EXPORT void STDCALL glClipPlanexOES(uint32_t plane, GLfixed* equation);
EXPORT void STDCALL glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
EXPORT void STDCALL glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
EXPORT void STDCALL glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
EXPORT void STDCALL glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
EXPORT void STDCALL glColorPointer(GLint size, uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glCurrentPaletteMatrixOES(GLuint matrixpaletteindex);
EXPORT void STDCALL glDeleteFramebuffersOES(GLsizei n, GLuint* framebuffers);
EXPORT void STDCALL glDeleteRenderbuffersOES(GLsizei n, GLuint* renderbuffers);
EXPORT void STDCALL glDepthRangefOES(GLclampf n, GLclampf f);
EXPORT void STDCALL glDepthRangex(GLfixed n, GLfixed f);
EXPORT void STDCALL glDepthRangexOES(GLfixed n, GLfixed f);
EXPORT void STDCALL glDisableClientState(uint32_t array);
EXPORT void STDCALL glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
EXPORT void STDCALL glDrawTexfvOES(GLfloat* coords);
EXPORT void STDCALL glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);
EXPORT void STDCALL glDrawTexivOES(GLint* coords);
EXPORT void STDCALL glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
EXPORT void STDCALL glDrawTexsvOES(GLshort* coords);
EXPORT void STDCALL glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
EXPORT void STDCALL glDrawTexxvOES(GLfixed* coords);
EXPORT void STDCALL glEnableClientState(uint32_t array);
EXPORT void STDCALL glFogf(uint32_t pname, GLfloat param);
EXPORT void STDCALL glFogfv(uint32_t pname, GLfloat* params);
EXPORT void STDCALL glFogx(uint32_t pname, GLfixed param);
EXPORT void STDCALL glFogxOES(uint32_t pname, GLfixed param);
EXPORT void STDCALL glFogxv(uint32_t pname, GLfixed* param);
EXPORT void STDCALL glFogxvOES(uint32_t pname, GLfixed* param);
EXPORT void STDCALL glFramebufferRenderbufferOES(uint32_t target, uint32_t attachment, uint32_t renderbuffertarget, GLuint renderbuffer);
EXPORT void STDCALL glFramebufferTexture2DOES(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level);
EXPORT void STDCALL glFrustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
EXPORT void STDCALL glFrustumfOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
EXPORT void STDCALL glFrustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
EXPORT void STDCALL glFrustumxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
EXPORT void STDCALL glGenFramebuffersOES(GLsizei n, GLuint* framebuffers);
EXPORT void STDCALL glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers);
EXPORT void STDCALL glGenerateMipmapOES(uint32_t target);
EXPORT void STDCALL glGetClipPlanef(uint32_t plane, GLfloat* equation);
EXPORT void STDCALL glGetClipPlanefOES(uint32_t plane, GLfloat* equation);
EXPORT void STDCALL glGetClipPlanex(uint32_t plane, GLfixed* equation);
EXPORT void STDCALL glGetClipPlanexOES(uint32_t plane, GLfixed* equation);
EXPORT void STDCALL glGetFixedv(uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetFixedvOES(uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetFramebufferAttachmentParameterivOES(uint32_t target, uint32_t attachment, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetLightfv(uint32_t light, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetLightxv(uint32_t light, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetLightxvOES(uint32_t light, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetMaterialfv(uint32_t face, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetMaterialxv(uint32_t face, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetMaterialxvOES(uint32_t face, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetRenderbufferParameterivOES(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexEnvfv(uint32_t target, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetTexEnviv(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexEnvxv(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetTexEnvxvOES(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetTexGenfvOES(uint32_t coord, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glGetTexGenivOES(uint32_t coord, uint32_t pname, GLint* params);
EXPORT void STDCALL glGetTexGenxvOES(uint32_t coord, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetTexParameterxv(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glGetTexParameterxvOES(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT GLboolean STDCALL glIsFramebufferOES(GLuint framebuffer);
EXPORT GLboolean STDCALL glIsRenderbufferOES(GLuint renderbuffer);
EXPORT void STDCALL glLightModelf(uint32_t pname, GLfloat param);
EXPORT void STDCALL glLightModelfv(uint32_t pname, GLfloat* params);
EXPORT void STDCALL glLightModelx(uint32_t pname, GLfixed param);
EXPORT void STDCALL glLightModelxOES(uint32_t pname, GLfixed param);
EXPORT void STDCALL glLightModelxv(uint32_t pname, GLfixed* param);
EXPORT void STDCALL glLightModelxvOES(uint32_t pname, GLfixed* param);
EXPORT void STDCALL glLightf(uint32_t light, uint32_t pname, GLfloat param);
EXPORT void STDCALL glLightfv(uint32_t light, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glLightx(uint32_t light, uint32_t pname, GLfixed param);
EXPORT void STDCALL glLightxOES(uint32_t light, uint32_t pname, GLfixed param);
EXPORT void STDCALL glLightxv(uint32_t light, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glLightxvOES(uint32_t light, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glLineWidthx(GLfixed width);
EXPORT void STDCALL glLineWidthxOES(GLfixed width);
EXPORT void STDCALL glLoadIdentity();
EXPORT void STDCALL glLoadMatrixf(GLfloat* m);
EXPORT void STDCALL glLoadMatrixx(GLfixed* m);
EXPORT void STDCALL glLoadMatrixxOES(GLfixed* m);
EXPORT void STDCALL glLoadPaletteFromModelViewMatrixOES();
EXPORT void STDCALL glLogicOp(uint32_t opcode);
EXPORT void STDCALL glMaterialf(uint32_t face, uint32_t pname, GLfloat param);
EXPORT void STDCALL glMaterialfv(uint32_t face, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glMaterialx(uint32_t face, uint32_t pname, GLfixed param);
EXPORT void STDCALL glMaterialxOES(uint32_t face, uint32_t pname, GLfixed param);
EXPORT void STDCALL glMaterialxv(uint32_t face, uint32_t pname, GLfixed* param);
EXPORT void STDCALL glMaterialxvOES(uint32_t face, uint32_t pname, GLfixed* param);
EXPORT void STDCALL glMatrixIndexPointerOES(GLint size, uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glMatrixMode(uint32_t mode);
EXPORT void STDCALL glMultMatrixf(GLfloat* m);
EXPORT void STDCALL glMultMatrixx(GLfixed* m);
EXPORT void STDCALL glMultMatrixxOES(GLfixed* m);
EXPORT void STDCALL glMultiTexCoord4f(uint32_t target, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
EXPORT void STDCALL glMultiTexCoord4x(uint32_t texture, GLfixed v0, GLfixed v1, GLfixed v2, GLfixed v3);
EXPORT void STDCALL glMultiTexCoord4xOES(uint32_t texture, GLfixed v0, GLfixed v1, GLfixed v2, GLfixed v3);
EXPORT void STDCALL glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);
EXPORT void STDCALL glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz);
EXPORT void STDCALL glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz);
EXPORT void STDCALL glNormalPointer(uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glOrthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
EXPORT void STDCALL glOrthofOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
EXPORT void STDCALL glOrthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
EXPORT void STDCALL glOrthoxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
EXPORT void STDCALL glPointParameterf(uint32_t pname, GLfloat param);
EXPORT void STDCALL glPointParameterfv(uint32_t pname, GLfloat* params);
EXPORT void STDCALL glPointParameterx(uint32_t pname, GLfixed param);
EXPORT void STDCALL glPointParameterxOES(uint32_t pname, GLfixed param);
EXPORT void STDCALL glPointParameterxv(uint32_t pname, GLfixed* params);
EXPORT void STDCALL glPointParameterxvOES(uint32_t pname, GLfixed* params);
EXPORT void STDCALL glPointSize(GLfloat size);
EXPORT void STDCALL glPointSizePointerOES(uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glPointSizex(GLfixed size);
EXPORT void STDCALL glPointSizexOES(GLfixed size);
EXPORT void STDCALL glPolygonOffsetx(GLfixed factor, GLfixed units);
EXPORT void STDCALL glPolygonOffsetxOES(GLfixed factor, GLfixed units);
EXPORT void STDCALL glPopMatrix();
EXPORT void STDCALL glPushMatrix();
EXPORT uint32_t STDCALL glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent);
EXPORT void STDCALL glRenderbufferStorageOES(uint32_t target, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
EXPORT void STDCALL glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
EXPORT void STDCALL glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
EXPORT void STDCALL glSampleCoveragex(GLclampx value, GLboolean invert);
EXPORT void STDCALL glSampleCoveragexOES(GLclampx value, GLboolean invert);
EXPORT void STDCALL glScalef(GLfloat x, GLfloat y, GLfloat z);
EXPORT void STDCALL glScalex(GLfixed x, GLfixed y, GLfixed z);
EXPORT void STDCALL glScalexOES(GLfixed x, GLfixed y, GLfixed z);
EXPORT void STDCALL glShadeModel(uint32_t mode);
EXPORT void STDCALL glTexCoordPointer(GLint size, uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glTexEnvf(uint32_t target, uint32_t pname, GLfloat param);
EXPORT void STDCALL glTexEnvfv(uint32_t target, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glTexEnvi(uint32_t target, uint32_t pname, GLint param);
EXPORT void STDCALL glTexEnviv(uint32_t target, uint32_t pname, GLint* params);
EXPORT void STDCALL glTexEnvx(uint32_t target, uint32_t pname, GLfixed param);
EXPORT void STDCALL glTexEnvxOES(uint32_t target, uint32_t pname, GLfixed param);
EXPORT void STDCALL glTexEnvxv(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glTexEnvxvOES(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glTexGenfOES(uint32_t coord, uint32_t pname, GLfloat param);
EXPORT void STDCALL glTexGenfvOES(uint32_t coord, uint32_t pname, GLfloat* params);
EXPORT void STDCALL glTexGeniOES(uint32_t coord, uint32_t pname, GLint param);
EXPORT void STDCALL glTexGenivOES(uint32_t coord, uint32_t pname, GLint* params);
EXPORT void STDCALL glTexGenxOES(uint32_t coord, uint32_t pname, GLfixed param);
EXPORT void STDCALL glTexGenxvOES(uint32_t coord, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glTexParameterx(uint32_t target, uint32_t pname, GLfixed param);
EXPORT void STDCALL glTexParameterxOES(uint32_t target, uint32_t pname, GLfixed param);
EXPORT void STDCALL glTexParameterxv(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glTexParameterxvOES(uint32_t target, uint32_t pname, GLfixed* params);
EXPORT void STDCALL glTranslatef(GLfloat x, GLfloat y, GLfloat z);
EXPORT void STDCALL glTranslatex(GLfixed x, GLfixed y, GLfixed z);
EXPORT void STDCALL glTranslatexOES(GLfixed x, GLfixed y, GLfixed z);
EXPORT void STDCALL glVertexPointer(GLint size, uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glWeightPointerOES(GLint size, uint32_t type, GLsizei stride, void* pointer);
EXPORT void STDCALL glColorPointerBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count);
EXPORT void STDCALL glNormalPointerBounds(uint32_t type, GLsizei stride, void* pointer, GLsizei count);
EXPORT void STDCALL glTexCoordPointerBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count);
EXPORT void STDCALL glVertexPointerBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count);
EXPORT void STDCALL glPointSizePointerOESBounds(uint32_t type, GLsizei stride, void* pointer, GLsizei count);
EXPORT void STDCALL glMatrixIndexPointerOESBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count);
EXPORT void STDCALL glWeightPointerOESBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count);

EXPORT void* STDCALL eglGetProcAddress(const char* name);
EXPORT void* STDCALL wglGetProcAddress(const char* name);
EXPORT void* STDCALL glXGetProcAddress(const char* name);
EXPORT void* STDCALL glXGetProcAddressARB(const char* name);
} // extern "C"

namespace gapii {
    const Symbol kGLESExports[] = {
        {"glBlendBarrierKHR", reinterpret_cast<void*>(glBlendBarrierKHR)},
        {"glBlendEquationSeparateiEXT", reinterpret_cast<void*>(glBlendEquationSeparateiEXT)},
        {"glBlendEquationiEXT", reinterpret_cast<void*>(glBlendEquationiEXT)},
        {"glBlendFuncSeparateiEXT", reinterpret_cast<void*>(glBlendFuncSeparateiEXT)},
        {"glBlendFunciEXT", reinterpret_cast<void*>(glBlendFunciEXT)},
        {"glColorMaskiEXT", reinterpret_cast<void*>(glColorMaskiEXT)},
        {"glCopyImageSubDataEXT", reinterpret_cast<void*>(glCopyImageSubDataEXT)},
        {"glDebugMessageCallbackKHR", reinterpret_cast<void*>(glDebugMessageCallbackKHR)},
        {"glDebugMessageControlKHR", reinterpret_cast<void*>(glDebugMessageControlKHR)},
        {"glDebugMessageInsertKHR", reinterpret_cast<void*>(glDebugMessageInsertKHR)},
        {"glDisableiEXT", reinterpret_cast<void*>(glDisableiEXT)},
        {"glEnableiEXT", reinterpret_cast<void*>(glEnableiEXT)},
        {"glFramebufferTextureEXT", reinterpret_cast<void*>(glFramebufferTextureEXT)},
        {"glGetDebugMessageLogKHR", reinterpret_cast<void*>(glGetDebugMessageLogKHR)},
        {"glGetObjectLabelKHR", reinterpret_cast<void*>(glGetObjectLabelKHR)},
        {"glGetObjectPtrLabelKHR", reinterpret_cast<void*>(glGetObjectPtrLabelKHR)},
        {"glGetPointervKHR", reinterpret_cast<void*>(glGetPointervKHR)},
        {"glGetSamplerParameterIivEXT", reinterpret_cast<void*>(glGetSamplerParameterIivEXT)},
        {"glGetSamplerParameterIuivEXT", reinterpret_cast<void*>(glGetSamplerParameterIuivEXT)},
        {"glGetTexParameterIivEXT", reinterpret_cast<void*>(glGetTexParameterIivEXT)},
        {"glGetTexParameterIuivEXT", reinterpret_cast<void*>(glGetTexParameterIuivEXT)},
        {"glIsEnablediEXT", reinterpret_cast<void*>(glIsEnablediEXT)},
        {"glMinSampleShadingOES", reinterpret_cast<void*>(glMinSampleShadingOES)},
        {"glObjectLabelKHR", reinterpret_cast<void*>(glObjectLabelKHR)},
        {"glObjectPtrLabelKHR", reinterpret_cast<void*>(glObjectPtrLabelKHR)},
        {"glPatchParameteriEXT", reinterpret_cast<void*>(glPatchParameteriEXT)},
        {"glPopDebugGroupKHR", reinterpret_cast<void*>(glPopDebugGroupKHR)},
        {"glPrimitiveBoundingBoxEXT", reinterpret_cast<void*>(glPrimitiveBoundingBoxEXT)},
        {"glPushDebugGroupKHR", reinterpret_cast<void*>(glPushDebugGroupKHR)},
        {"glSamplerParameterIivEXT", reinterpret_cast<void*>(glSamplerParameterIivEXT)},
        {"glSamplerParameterIuivEXT", reinterpret_cast<void*>(glSamplerParameterIuivEXT)},
        {"glTexBufferEXT", reinterpret_cast<void*>(glTexBufferEXT)},
        {"glTexBufferRangeEXT", reinterpret_cast<void*>(glTexBufferRangeEXT)},
        {"glTexParameterIivEXT", reinterpret_cast<void*>(glTexParameterIivEXT)},
        {"glTexParameterIuivEXT", reinterpret_cast<void*>(glTexParameterIuivEXT)},
        {"glTexStorage3DMultisampleOES", reinterpret_cast<void*>(glTexStorage3DMultisampleOES)},
        {"glBeginQuery", reinterpret_cast<void*>(glBeginQuery)},
        {"glDeleteQueries", reinterpret_cast<void*>(glDeleteQueries)},
        {"glEndQuery", reinterpret_cast<void*>(glEndQuery)},
        {"glGenQueries", reinterpret_cast<void*>(glGenQueries)},
        {"glGetQueryObjectuiv", reinterpret_cast<void*>(glGetQueryObjectuiv)},
        {"glGetQueryiv", reinterpret_cast<void*>(glGetQueryiv)},
        {"glIsQuery", reinterpret_cast<void*>(glIsQuery)},
        {"glBindBuffer", reinterpret_cast<void*>(glBindBuffer)},
        {"glBindBufferBase", reinterpret_cast<void*>(glBindBufferBase)},
        {"glBindBufferRange", reinterpret_cast<void*>(glBindBufferRange)},
        {"glBufferData", reinterpret_cast<void*>(glBufferData)},
        {"glBufferSubData", reinterpret_cast<void*>(glBufferSubData)},
        {"glCopyBufferSubData", reinterpret_cast<void*>(glCopyBufferSubData)},
        {"glDeleteBuffers", reinterpret_cast<void*>(glDeleteBuffers)},
        {"glGenBuffers", reinterpret_cast<void*>(glGenBuffers)},
        {"glGetBufferParameteri64v", reinterpret_cast<void*>(glGetBufferParameteri64v)},
        {"glGetBufferParameteriv", reinterpret_cast<void*>(glGetBufferParameteriv)},
        {"glGetBufferPointerv", reinterpret_cast<void*>(glGetBufferPointerv)},
        {"glIsBuffer", reinterpret_cast<void*>(glIsBuffer)},
        {"glMapBufferRange", reinterpret_cast<void*>(glMapBufferRange)},
        {"glUnmapBuffer", reinterpret_cast<void*>(glUnmapBuffer)},
        {"glDebugMessageCallback", reinterpret_cast<void*>(glDebugMessageCallback)},
        {"glDebugMessageControl", reinterpret_cast<void*>(glDebugMessageControl)},
        {"glDebugMessageInsert", reinterpret_cast<void*>(glDebugMessageInsert)},
        {"glGetDebugMessageLog", reinterpret_cast<void*>(glGetDebugMessageLog)},
        {"glGetObjectLabel", reinterpret_cast<void*>(glGetObjectLabel)},
        {"glGetObjectPtrLabel", reinterpret_cast<void*>(glGetObjectPtrLabel)},
        {"glGetPointerv", reinterpret_cast<void*>(glGetPointerv)},
        {"glObjectLabel", reinterpret_cast<void*>(glObjectLabel)},
        {"glObjectPtrLabel", reinterpret_cast<void*>(glObjectPtrLabel)},
        {"glPopDebugGroup", reinterpret_cast<void*>(glPopDebugGroup)},
        {"glPushDebugGroup", reinterpret_cast<void*>(glPushDebugGroup)},
        {"glDrawArrays", reinterpret_cast<void*>(glDrawArrays)},
        {"glDrawArraysIndirect", reinterpret_cast<void*>(glDrawArraysIndirect)},
        {"glDrawArraysInstanced", reinterpret_cast<void*>(glDrawArraysInstanced)},
        {"glDrawElements", reinterpret_cast<void*>(glDrawElements)},
        {"glDrawElementsBaseVertex", reinterpret_cast<void*>(glDrawElementsBaseVertex)},
        {"glDrawElementsIndirect", reinterpret_cast<void*>(glDrawElementsIndirect)},
        {"glDrawElementsInstanced", reinterpret_cast<void*>(glDrawElementsInstanced)},
        {"glDrawElementsInstancedBaseVertex", reinterpret_cast<void*>(glDrawElementsInstancedBaseVertex)},
        {"glDrawRangeElements", reinterpret_cast<void*>(glDrawRangeElements)},
        {"glDrawRangeElementsBaseVertex", reinterpret_cast<void*>(glDrawRangeElementsBaseVertex)},
        {"glPatchParameteri", reinterpret_cast<void*>(glPatchParameteri)},
        {"glPrimitiveBoundingBox", reinterpret_cast<void*>(glPrimitiveBoundingBox)},
        {"glActiveShaderProgramEXT", reinterpret_cast<void*>(glActiveShaderProgramEXT)},
        {"glAlphaFuncQCOM", reinterpret_cast<void*>(glAlphaFuncQCOM)},
        {"glApplyFramebufferAttachmentCMAAINTEL", reinterpret_cast<void*>(glApplyFramebufferAttachmentCMAAINTEL)},
        {"glBeginConditionalRenderNV", reinterpret_cast<void*>(glBeginConditionalRenderNV)},
        {"glBeginPerfMonitorAMD", reinterpret_cast<void*>(glBeginPerfMonitorAMD)},
        {"glBeginPerfQueryINTEL", reinterpret_cast<void*>(glBeginPerfQueryINTEL)},
        {"glBeginQueryEXT", reinterpret_cast<void*>(glBeginQueryEXT)},
        {"glBindFragDataLocationEXT", reinterpret_cast<void*>(glBindFragDataLocationEXT)},
        {"glBindFragDataLocationIndexedEXT", reinterpret_cast<void*>(glBindFragDataLocationIndexedEXT)},
        {"glBindProgramPipelineEXT", reinterpret_cast<void*>(glBindProgramPipelineEXT)},
        {"glBindVertexArrayOES", reinterpret_cast<void*>(glBindVertexArrayOES)},
        {"glBlendBarrierNV", reinterpret_cast<void*>(glBlendBarrierNV)},
        {"glBlendEquationSeparateiOES", reinterpret_cast<void*>(glBlendEquationSeparateiOES)},
        {"glBlendEquationiOES", reinterpret_cast<void*>(glBlendEquationiOES)},
        {"glBlendFuncSeparateiOES", reinterpret_cast<void*>(glBlendFuncSeparateiOES)},
        {"glBlendFunciOES", reinterpret_cast<void*>(glBlendFunciOES)},
        {"glBlendParameteriNV", reinterpret_cast<void*>(glBlendParameteriNV)},
        {"glBlitFramebufferANGLE", reinterpret_cast<void*>(glBlitFramebufferANGLE)},
        {"glBlitFramebufferNV", reinterpret_cast<void*>(glBlitFramebufferNV)},
        {"glBufferStorageEXT", reinterpret_cast<void*>(glBufferStorageEXT)},
        {"glClientWaitSyncAPPLE", reinterpret_cast<void*>(glClientWaitSyncAPPLE)},
        {"glColorMaskiOES", reinterpret_cast<void*>(glColorMaskiOES)},
        {"glCompressedTexImage3DOES", reinterpret_cast<void*>(glCompressedTexImage3DOES)},
        {"glCompressedTexSubImage3DOES", reinterpret_cast<void*>(glCompressedTexSubImage3DOES)},
        {"glCopyBufferSubDataNV", reinterpret_cast<void*>(glCopyBufferSubDataNV)},
        {"glCopyImageSubDataOES", reinterpret_cast<void*>(glCopyImageSubDataOES)},
        {"glCopyPathNV", reinterpret_cast<void*>(glCopyPathNV)},
        {"glCopyTexSubImage3DOES", reinterpret_cast<void*>(glCopyTexSubImage3DOES)},
        {"glCopyTextureLevelsAPPLE", reinterpret_cast<void*>(glCopyTextureLevelsAPPLE)},
        {"glCoverFillPathInstancedNV", reinterpret_cast<void*>(glCoverFillPathInstancedNV)},
        {"glCoverFillPathNV", reinterpret_cast<void*>(glCoverFillPathNV)},
        {"glCoverStrokePathInstancedNV", reinterpret_cast<void*>(glCoverStrokePathInstancedNV)},
        {"glCoverStrokePathNV", reinterpret_cast<void*>(glCoverStrokePathNV)},
        {"glCoverageMaskNV", reinterpret_cast<void*>(glCoverageMaskNV)},
        {"glCoverageModulationNV", reinterpret_cast<void*>(glCoverageModulationNV)},
        {"glCoverageModulationTableNV", reinterpret_cast<void*>(glCoverageModulationTableNV)},
        {"glCoverageOperationNV", reinterpret_cast<void*>(glCoverageOperationNV)},
        {"glCreatePerfQueryINTEL", reinterpret_cast<void*>(glCreatePerfQueryINTEL)},
        {"glCreateShaderProgramvEXT", reinterpret_cast<void*>(glCreateShaderProgramvEXT)},
        {"glDeleteFencesNV", reinterpret_cast<void*>(glDeleteFencesNV)},
        {"glDeletePathsNV", reinterpret_cast<void*>(glDeletePathsNV)},
        {"glDeletePerfMonitorsAMD", reinterpret_cast<void*>(glDeletePerfMonitorsAMD)},
        {"glDeletePerfQueryINTEL", reinterpret_cast<void*>(glDeletePerfQueryINTEL)},
        {"glDeleteProgramPipelinesEXT", reinterpret_cast<void*>(glDeleteProgramPipelinesEXT)},
        {"glDeleteQueriesEXT", reinterpret_cast<void*>(glDeleteQueriesEXT)},
        {"glDeleteSyncAPPLE", reinterpret_cast<void*>(glDeleteSyncAPPLE)},
        {"glDeleteVertexArraysOES", reinterpret_cast<void*>(glDeleteVertexArraysOES)},
        {"glDepthRangeArrayfvNV", reinterpret_cast<void*>(glDepthRangeArrayfvNV)},
        {"glDepthRangeIndexedfNV", reinterpret_cast<void*>(glDepthRangeIndexedfNV)},
        {"glDisableDriverControlQCOM", reinterpret_cast<void*>(glDisableDriverControlQCOM)},
        {"glDisableiNV", reinterpret_cast<void*>(glDisableiNV)},
        {"glDisableiOES", reinterpret_cast<void*>(glDisableiOES)},
        {"glDiscardFramebufferEXT", reinterpret_cast<void*>(glDiscardFramebufferEXT)},
        {"glDrawArraysInstancedANGLE", reinterpret_cast<void*>(glDrawArraysInstancedANGLE)},
        {"glDrawArraysInstancedBaseInstanceEXT", reinterpret_cast<void*>(glDrawArraysInstancedBaseInstanceEXT)},
        {"glDrawArraysInstancedEXT", reinterpret_cast<void*>(glDrawArraysInstancedEXT)},
        {"glDrawArraysInstancedNV", reinterpret_cast<void*>(glDrawArraysInstancedNV)},
        {"glDrawBuffersEXT", reinterpret_cast<void*>(glDrawBuffersEXT)},
        {"glDrawBuffersIndexedEXT", reinterpret_cast<void*>(glDrawBuffersIndexedEXT)},
        {"glDrawBuffersNV", reinterpret_cast<void*>(glDrawBuffersNV)},
        {"glDrawElementsBaseVertexEXT", reinterpret_cast<void*>(glDrawElementsBaseVertexEXT)},
        {"glDrawElementsBaseVertexOES", reinterpret_cast<void*>(glDrawElementsBaseVertexOES)},
        {"glDrawElementsInstancedANGLE", reinterpret_cast<void*>(glDrawElementsInstancedANGLE)},
        {"glDrawElementsInstancedBaseInstanceEXT", reinterpret_cast<void*>(glDrawElementsInstancedBaseInstanceEXT)},
        {"glDrawElementsInstancedBaseVertexBaseInstanceEXT", reinterpret_cast<void*>(glDrawElementsInstancedBaseVertexBaseInstanceEXT)},
        {"glDrawElementsInstancedBaseVertexEXT", reinterpret_cast<void*>(glDrawElementsInstancedBaseVertexEXT)},
        {"glDrawElementsInstancedBaseVertexOES", reinterpret_cast<void*>(glDrawElementsInstancedBaseVertexOES)},
        {"glDrawElementsInstancedEXT", reinterpret_cast<void*>(glDrawElementsInstancedEXT)},
        {"glDrawElementsInstancedNV", reinterpret_cast<void*>(glDrawElementsInstancedNV)},
        {"glDrawRangeElementsBaseVertexEXT", reinterpret_cast<void*>(glDrawRangeElementsBaseVertexEXT)},
        {"glDrawRangeElementsBaseVertexOES", reinterpret_cast<void*>(glDrawRangeElementsBaseVertexOES)},
        {"glEGLImageTargetRenderbufferStorageOES", reinterpret_cast<void*>(glEGLImageTargetRenderbufferStorageOES)},
        {"glEGLImageTargetTexture2DOES", reinterpret_cast<void*>(glEGLImageTargetTexture2DOES)},
        {"glEnableDriverControlQCOM", reinterpret_cast<void*>(glEnableDriverControlQCOM)},
        {"glEnableiNV", reinterpret_cast<void*>(glEnableiNV)},
        {"glEnableiOES", reinterpret_cast<void*>(glEnableiOES)},
        {"glEndConditionalRenderNV", reinterpret_cast<void*>(glEndConditionalRenderNV)},
        {"glEndPerfMonitorAMD", reinterpret_cast<void*>(glEndPerfMonitorAMD)},
        {"glEndPerfQueryINTEL", reinterpret_cast<void*>(glEndPerfQueryINTEL)},
        {"glEndQueryEXT", reinterpret_cast<void*>(glEndQueryEXT)},
        {"glEndTilingQCOM", reinterpret_cast<void*>(glEndTilingQCOM)},
        {"glExtGetBufferPointervQCOM", reinterpret_cast<void*>(glExtGetBufferPointervQCOM)},
        {"glExtGetBuffersQCOM", reinterpret_cast<void*>(glExtGetBuffersQCOM)},
        {"glExtGetFramebuffersQCOM", reinterpret_cast<void*>(glExtGetFramebuffersQCOM)},
        {"glExtGetProgramBinarySourceQCOM", reinterpret_cast<void*>(glExtGetProgramBinarySourceQCOM)},
        {"glExtGetProgramsQCOM", reinterpret_cast<void*>(glExtGetProgramsQCOM)},
        {"glExtGetRenderbuffersQCOM", reinterpret_cast<void*>(glExtGetRenderbuffersQCOM)},
        {"glExtGetShadersQCOM", reinterpret_cast<void*>(glExtGetShadersQCOM)},
        {"glExtGetTexLevelParameterivQCOM", reinterpret_cast<void*>(glExtGetTexLevelParameterivQCOM)},
        {"glExtGetTexSubImageQCOM", reinterpret_cast<void*>(glExtGetTexSubImageQCOM)},
        {"glExtGetTexturesQCOM", reinterpret_cast<void*>(glExtGetTexturesQCOM)},
        {"glExtIsProgramBinaryQCOM", reinterpret_cast<void*>(glExtIsProgramBinaryQCOM)},
        {"glExtTexObjectStateOverrideiQCOM", reinterpret_cast<void*>(glExtTexObjectStateOverrideiQCOM)},
        {"glFenceSyncAPPLE", reinterpret_cast<void*>(glFenceSyncAPPLE)},
        {"glFinishFenceNV", reinterpret_cast<void*>(glFinishFenceNV)},
        {"glFlushMappedBufferRangeEXT", reinterpret_cast<void*>(glFlushMappedBufferRangeEXT)},
        {"glFragmentCoverageColorNV", reinterpret_cast<void*>(glFragmentCoverageColorNV)},
        {"glFramebufferSampleLocationsfvNV", reinterpret_cast<void*>(glFramebufferSampleLocationsfvNV)},
        {"glFramebufferTexture2DMultisampleEXT", reinterpret_cast<void*>(glFramebufferTexture2DMultisampleEXT)},
        {"glFramebufferTexture2DMultisampleIMG", reinterpret_cast<void*>(glFramebufferTexture2DMultisampleIMG)},
        {"glFramebufferTexture3DOES", reinterpret_cast<void*>(glFramebufferTexture3DOES)},
        {"glFramebufferTextureMultiviewOVR", reinterpret_cast<void*>(glFramebufferTextureMultiviewOVR)},
        {"glFramebufferTextureOES", reinterpret_cast<void*>(glFramebufferTextureOES)},
        {"glGenFencesNV", reinterpret_cast<void*>(glGenFencesNV)},
        {"glGenPathsNV", reinterpret_cast<void*>(glGenPathsNV)},
        {"glGenPerfMonitorsAMD", reinterpret_cast<void*>(glGenPerfMonitorsAMD)},
        {"glGenProgramPipelinesEXT", reinterpret_cast<void*>(glGenProgramPipelinesEXT)},
        {"glGenQueriesEXT", reinterpret_cast<void*>(glGenQueriesEXT)},
        {"glGenVertexArraysOES", reinterpret_cast<void*>(glGenVertexArraysOES)},
        {"glGetBufferPointervOES", reinterpret_cast<void*>(glGetBufferPointervOES)},
        {"glGetCoverageModulationTableNV", reinterpret_cast<void*>(glGetCoverageModulationTableNV)},
        {"glGetDriverControlStringQCOM", reinterpret_cast<void*>(glGetDriverControlStringQCOM)},
        {"glGetDriverControlsQCOM", reinterpret_cast<void*>(glGetDriverControlsQCOM)},
        {"glGetFenceivNV", reinterpret_cast<void*>(glGetFenceivNV)},
        {"glGetFirstPerfQueryIdINTEL", reinterpret_cast<void*>(glGetFirstPerfQueryIdINTEL)},
        {"glGetFloati_vNV", reinterpret_cast<void*>(glGetFloati_vNV)},
        {"glGetFragDataIndexEXT", reinterpret_cast<void*>(glGetFragDataIndexEXT)},
        {"glGetGraphicsResetStatusEXT", reinterpret_cast<void*>(glGetGraphicsResetStatusEXT)},
        {"glGetGraphicsResetStatusKHR", reinterpret_cast<void*>(glGetGraphicsResetStatusKHR)},
        {"glGetImageHandleNV", reinterpret_cast<void*>(glGetImageHandleNV)},
        {"glGetInteger64vAPPLE", reinterpret_cast<void*>(glGetInteger64vAPPLE)},
        {"glGetIntegeri_vEXT", reinterpret_cast<void*>(glGetIntegeri_vEXT)},
        {"glGetInternalformatSampleivNV", reinterpret_cast<void*>(glGetInternalformatSampleivNV)},
        {"glGetNextPerfQueryIdINTEL", reinterpret_cast<void*>(glGetNextPerfQueryIdINTEL)},
        {"glGetObjectLabelEXT", reinterpret_cast<void*>(glGetObjectLabelEXT)},
        {"glGetPathCommandsNV", reinterpret_cast<void*>(glGetPathCommandsNV)},
        {"glGetPathCoordsNV", reinterpret_cast<void*>(glGetPathCoordsNV)},
        {"glGetPathDashArrayNV", reinterpret_cast<void*>(glGetPathDashArrayNV)},
        {"glGetPathLengthNV", reinterpret_cast<void*>(glGetPathLengthNV)},
        {"glGetPathMetricRangeNV", reinterpret_cast<void*>(glGetPathMetricRangeNV)},
        {"glGetPathMetricsNV", reinterpret_cast<void*>(glGetPathMetricsNV)},
        {"glGetPathParameterfvNV", reinterpret_cast<void*>(glGetPathParameterfvNV)},
        {"glGetPathParameterivNV", reinterpret_cast<void*>(glGetPathParameterivNV)},
        {"glGetPathSpacingNV", reinterpret_cast<void*>(glGetPathSpacingNV)},
        {"glGetPerfCounterInfoINTEL", reinterpret_cast<void*>(glGetPerfCounterInfoINTEL)},
        {"glGetPerfMonitorCounterDataAMD", reinterpret_cast<void*>(glGetPerfMonitorCounterDataAMD)},
        {"glGetPerfMonitorCounterInfoAMD", reinterpret_cast<void*>(glGetPerfMonitorCounterInfoAMD)},
        {"glGetPerfMonitorCounterStringAMD", reinterpret_cast<void*>(glGetPerfMonitorCounterStringAMD)},
        {"glGetPerfMonitorCountersAMD", reinterpret_cast<void*>(glGetPerfMonitorCountersAMD)},
        {"glGetPerfMonitorGroupStringAMD", reinterpret_cast<void*>(glGetPerfMonitorGroupStringAMD)},
        {"glGetPerfMonitorGroupsAMD", reinterpret_cast<void*>(glGetPerfMonitorGroupsAMD)},
        {"glGetPerfQueryDataINTEL", reinterpret_cast<void*>(glGetPerfQueryDataINTEL)},
        {"glGetPerfQueryIdByNameINTEL", reinterpret_cast<void*>(glGetPerfQueryIdByNameINTEL)},
        {"glGetPerfQueryInfoINTEL", reinterpret_cast<void*>(glGetPerfQueryInfoINTEL)},
        {"glGetProgramBinaryOES", reinterpret_cast<void*>(glGetProgramBinaryOES)},
        {"glGetProgramPipelineInfoLogEXT", reinterpret_cast<void*>(glGetProgramPipelineInfoLogEXT)},
        {"glGetProgramPipelineivEXT", reinterpret_cast<void*>(glGetProgramPipelineivEXT)},
        {"glGetProgramResourceLocationIndexEXT", reinterpret_cast<void*>(glGetProgramResourceLocationIndexEXT)},
        {"glGetProgramResourcefvNV", reinterpret_cast<void*>(glGetProgramResourcefvNV)},
        {"glGetQueryObjecti64vEXT", reinterpret_cast<void*>(glGetQueryObjecti64vEXT)},
        {"glGetQueryObjectivEXT", reinterpret_cast<void*>(glGetQueryObjectivEXT)},
        {"glGetQueryObjectui64vEXT", reinterpret_cast<void*>(glGetQueryObjectui64vEXT)},
        {"glGetQueryObjectuivEXT", reinterpret_cast<void*>(glGetQueryObjectuivEXT)},
        {"glGetQueryivEXT", reinterpret_cast<void*>(glGetQueryivEXT)},
        {"glGetSamplerParameterIivOES", reinterpret_cast<void*>(glGetSamplerParameterIivOES)},
        {"glGetSamplerParameterIuivOES", reinterpret_cast<void*>(glGetSamplerParameterIuivOES)},
        {"glGetSyncivAPPLE", reinterpret_cast<void*>(glGetSyncivAPPLE)},
        {"glGetTexParameterIivOES", reinterpret_cast<void*>(glGetTexParameterIivOES)},
        {"glGetTexParameterIuivOES", reinterpret_cast<void*>(glGetTexParameterIuivOES)},
        {"glGetTextureHandleNV", reinterpret_cast<void*>(glGetTextureHandleNV)},
        {"glGetTextureSamplerHandleNV", reinterpret_cast<void*>(glGetTextureSamplerHandleNV)},
        {"glGetTranslatedShaderSourceANGLE", reinterpret_cast<void*>(glGetTranslatedShaderSourceANGLE)},
        {"glGetnUniformfvEXT", reinterpret_cast<void*>(glGetnUniformfvEXT)},
        {"glGetnUniformfvKHR", reinterpret_cast<void*>(glGetnUniformfvKHR)},
        {"glGetnUniformivEXT", reinterpret_cast<void*>(glGetnUniformivEXT)},
        {"glGetnUniformivKHR", reinterpret_cast<void*>(glGetnUniformivKHR)},
        {"glGetnUniformuivKHR", reinterpret_cast<void*>(glGetnUniformuivKHR)},
        {"glInsertEventMarkerEXT", reinterpret_cast<void*>(glInsertEventMarkerEXT)},
        {"glInterpolatePathsNV", reinterpret_cast<void*>(glInterpolatePathsNV)},
        {"glIsEnablediNV", reinterpret_cast<void*>(glIsEnablediNV)},
        {"glIsEnablediOES", reinterpret_cast<void*>(glIsEnablediOES)},
        {"glIsFenceNV", reinterpret_cast<void*>(glIsFenceNV)},
        {"glIsImageHandleResidentNV", reinterpret_cast<void*>(glIsImageHandleResidentNV)},
        {"glIsPathNV", reinterpret_cast<void*>(glIsPathNV)},
        {"glIsPointInFillPathNV", reinterpret_cast<void*>(glIsPointInFillPathNV)},
        {"glIsPointInStrokePathNV", reinterpret_cast<void*>(glIsPointInStrokePathNV)},
        {"glIsProgramPipelineEXT", reinterpret_cast<void*>(glIsProgramPipelineEXT)},
        {"glIsQueryEXT", reinterpret_cast<void*>(glIsQueryEXT)},
        {"glIsSyncAPPLE", reinterpret_cast<void*>(glIsSyncAPPLE)},
        {"glIsTextureHandleResidentNV", reinterpret_cast<void*>(glIsTextureHandleResidentNV)},
        {"glIsVertexArrayOES", reinterpret_cast<void*>(glIsVertexArrayOES)},
        {"glLabelObjectEXT", reinterpret_cast<void*>(glLabelObjectEXT)},
        {"glMakeImageHandleNonResidentNV", reinterpret_cast<void*>(glMakeImageHandleNonResidentNV)},
        {"glMakeImageHandleResidentNV", reinterpret_cast<void*>(glMakeImageHandleResidentNV)},
        {"glMakeTextureHandleNonResidentNV", reinterpret_cast<void*>(glMakeTextureHandleNonResidentNV)},
        {"glMakeTextureHandleResidentNV", reinterpret_cast<void*>(glMakeTextureHandleResidentNV)},
        {"glMapBufferOES", reinterpret_cast<void*>(glMapBufferOES)},
        {"glMapBufferRangeEXT", reinterpret_cast<void*>(glMapBufferRangeEXT)},
        {"glMatrixLoad3x2fNV", reinterpret_cast<void*>(glMatrixLoad3x2fNV)},
        {"glMatrixLoad3x3fNV", reinterpret_cast<void*>(glMatrixLoad3x3fNV)},
        {"glMatrixLoadTranspose3x3fNV", reinterpret_cast<void*>(glMatrixLoadTranspose3x3fNV)},
        {"glMatrixMult3x2fNV", reinterpret_cast<void*>(glMatrixMult3x2fNV)},
        {"glMatrixMult3x3fNV", reinterpret_cast<void*>(glMatrixMult3x3fNV)},
        {"glMatrixMultTranspose3x3fNV", reinterpret_cast<void*>(glMatrixMultTranspose3x3fNV)},
        {"glMultiDrawArraysEXT", reinterpret_cast<void*>(glMultiDrawArraysEXT)},
        {"glMultiDrawArraysIndirectEXT", reinterpret_cast<void*>(glMultiDrawArraysIndirectEXT)},
        {"glMultiDrawElementsBaseVertexEXT", reinterpret_cast<void*>(glMultiDrawElementsBaseVertexEXT)},
        {"glMultiDrawElementsBaseVertexOES", reinterpret_cast<void*>(glMultiDrawElementsBaseVertexOES)},
        {"glMultiDrawElementsEXT", reinterpret_cast<void*>(glMultiDrawElementsEXT)},
        {"glMultiDrawElementsIndirectEXT", reinterpret_cast<void*>(glMultiDrawElementsIndirectEXT)},
        {"glNamedFramebufferSampleLocationsfvNV", reinterpret_cast<void*>(glNamedFramebufferSampleLocationsfvNV)},
        {"glPatchParameteriOES", reinterpret_cast<void*>(glPatchParameteriOES)},
        {"glPathCommandsNV", reinterpret_cast<void*>(glPathCommandsNV)},
        {"glPathCoordsNV", reinterpret_cast<void*>(glPathCoordsNV)},
        {"glPathCoverDepthFuncNV", reinterpret_cast<void*>(glPathCoverDepthFuncNV)},
        {"glPathDashArrayNV", reinterpret_cast<void*>(glPathDashArrayNV)},
        {"glPathGlyphIndexArrayNV", reinterpret_cast<void*>(glPathGlyphIndexArrayNV)},
        {"glPathGlyphIndexRangeNV", reinterpret_cast<void*>(glPathGlyphIndexRangeNV)},
        {"glPathGlyphRangeNV", reinterpret_cast<void*>(glPathGlyphRangeNV)},
        {"glPathGlyphsNV", reinterpret_cast<void*>(glPathGlyphsNV)},
        {"glPathMemoryGlyphIndexArrayNV", reinterpret_cast<void*>(glPathMemoryGlyphIndexArrayNV)},
        {"glPathParameterfNV", reinterpret_cast<void*>(glPathParameterfNV)},
        {"glPathParameterfvNV", reinterpret_cast<void*>(glPathParameterfvNV)},
        {"glPathParameteriNV", reinterpret_cast<void*>(glPathParameteriNV)},
        {"glPathParameterivNV", reinterpret_cast<void*>(glPathParameterivNV)},
        {"glPathStencilDepthOffsetNV", reinterpret_cast<void*>(glPathStencilDepthOffsetNV)},
        {"glPathStencilFuncNV", reinterpret_cast<void*>(glPathStencilFuncNV)},
        {"glPathStringNV", reinterpret_cast<void*>(glPathStringNV)},
        {"glPathSubCommandsNV", reinterpret_cast<void*>(glPathSubCommandsNV)},
        {"glPathSubCoordsNV", reinterpret_cast<void*>(glPathSubCoordsNV)},
        {"glPointAlongPathNV", reinterpret_cast<void*>(glPointAlongPathNV)},
        {"glPolygonModeNV", reinterpret_cast<void*>(glPolygonModeNV)},
        {"glPopGroupMarkerEXT", reinterpret_cast<void*>(glPopGroupMarkerEXT)},
        {"glPrimitiveBoundingBoxOES", reinterpret_cast<void*>(glPrimitiveBoundingBoxOES)},
        {"glProgramBinaryOES", reinterpret_cast<void*>(glProgramBinaryOES)},
        {"glProgramParameteriEXT", reinterpret_cast<void*>(glProgramParameteriEXT)},
        {"glProgramPathFragmentInputGenNV", reinterpret_cast<void*>(glProgramPathFragmentInputGenNV)},
        {"glProgramUniform1fEXT", reinterpret_cast<void*>(glProgramUniform1fEXT)},
        {"glProgramUniform1fvEXT", reinterpret_cast<void*>(glProgramUniform1fvEXT)},
        {"glProgramUniform1iEXT", reinterpret_cast<void*>(glProgramUniform1iEXT)},
        {"glProgramUniform1ivEXT", reinterpret_cast<void*>(glProgramUniform1ivEXT)},
        {"glProgramUniform1uiEXT", reinterpret_cast<void*>(glProgramUniform1uiEXT)},
        {"glProgramUniform1uivEXT", reinterpret_cast<void*>(glProgramUniform1uivEXT)},
        {"glProgramUniform2fEXT", reinterpret_cast<void*>(glProgramUniform2fEXT)},
        {"glProgramUniform2fvEXT", reinterpret_cast<void*>(glProgramUniform2fvEXT)},
        {"glProgramUniform2iEXT", reinterpret_cast<void*>(glProgramUniform2iEXT)},
        {"glProgramUniform2ivEXT", reinterpret_cast<void*>(glProgramUniform2ivEXT)},
        {"glProgramUniform2uiEXT", reinterpret_cast<void*>(glProgramUniform2uiEXT)},
        {"glProgramUniform2uivEXT", reinterpret_cast<void*>(glProgramUniform2uivEXT)},
        {"glProgramUniform3fEXT", reinterpret_cast<void*>(glProgramUniform3fEXT)},
        {"glProgramUniform3fvEXT", reinterpret_cast<void*>(glProgramUniform3fvEXT)},
        {"glProgramUniform3iEXT", reinterpret_cast<void*>(glProgramUniform3iEXT)},
        {"glProgramUniform3ivEXT", reinterpret_cast<void*>(glProgramUniform3ivEXT)},
        {"glProgramUniform3uiEXT", reinterpret_cast<void*>(glProgramUniform3uiEXT)},
        {"glProgramUniform3uivEXT", reinterpret_cast<void*>(glProgramUniform3uivEXT)},
        {"glProgramUniform4fEXT", reinterpret_cast<void*>(glProgramUniform4fEXT)},
        {"glProgramUniform4fvEXT", reinterpret_cast<void*>(glProgramUniform4fvEXT)},
        {"glProgramUniform4iEXT", reinterpret_cast<void*>(glProgramUniform4iEXT)},
        {"glProgramUniform4ivEXT", reinterpret_cast<void*>(glProgramUniform4ivEXT)},
        {"glProgramUniform4uiEXT", reinterpret_cast<void*>(glProgramUniform4uiEXT)},
        {"glProgramUniform4uivEXT", reinterpret_cast<void*>(glProgramUniform4uivEXT)},
        {"glProgramUniformHandleui64NV", reinterpret_cast<void*>(glProgramUniformHandleui64NV)},
        {"glProgramUniformHandleui64vNV", reinterpret_cast<void*>(glProgramUniformHandleui64vNV)},
        {"glProgramUniformMatrix2fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix2fvEXT)},
        {"glProgramUniformMatrix2x3fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix2x3fvEXT)},
        {"glProgramUniformMatrix2x4fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix2x4fvEXT)},
        {"glProgramUniformMatrix3fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix3fvEXT)},
        {"glProgramUniformMatrix3x2fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix3x2fvEXT)},
        {"glProgramUniformMatrix3x4fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix3x4fvEXT)},
        {"glProgramUniformMatrix4fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix4fvEXT)},
        {"glProgramUniformMatrix4x2fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix4x2fvEXT)},
        {"glProgramUniformMatrix4x3fvEXT", reinterpret_cast<void*>(glProgramUniformMatrix4x3fvEXT)},
        {"glPushGroupMarkerEXT", reinterpret_cast<void*>(glPushGroupMarkerEXT)},
        {"glQueryCounterEXT", reinterpret_cast<void*>(glQueryCounterEXT)},
        {"glRasterSamplesEXT", reinterpret_cast<void*>(glRasterSamplesEXT)},
        {"glReadBufferIndexedEXT", reinterpret_cast<void*>(glReadBufferIndexedEXT)},
        {"glReadBufferNV", reinterpret_cast<void*>(glReadBufferNV)},
        {"glReadnPixelsEXT", reinterpret_cast<void*>(glReadnPixelsEXT)},
        {"glReadnPixelsKHR", reinterpret_cast<void*>(glReadnPixelsKHR)},
        {"glRenderbufferStorageMultisampleANGLE", reinterpret_cast<void*>(glRenderbufferStorageMultisampleANGLE)},
        {"glRenderbufferStorageMultisampleAPPLE", reinterpret_cast<void*>(glRenderbufferStorageMultisampleAPPLE)},
        {"glRenderbufferStorageMultisampleEXT", reinterpret_cast<void*>(glRenderbufferStorageMultisampleEXT)},
        {"glRenderbufferStorageMultisampleIMG", reinterpret_cast<void*>(glRenderbufferStorageMultisampleIMG)},
        {"glRenderbufferStorageMultisampleNV", reinterpret_cast<void*>(glRenderbufferStorageMultisampleNV)},
        {"glResolveDepthValuesNV", reinterpret_cast<void*>(glResolveDepthValuesNV)},
        {"glResolveMultisampleFramebufferAPPLE", reinterpret_cast<void*>(glResolveMultisampleFramebufferAPPLE)},
        {"glSamplerParameterIivOES", reinterpret_cast<void*>(glSamplerParameterIivOES)},
        {"glSamplerParameterIuivOES", reinterpret_cast<void*>(glSamplerParameterIuivOES)},
        {"glScissorArrayvNV", reinterpret_cast<void*>(glScissorArrayvNV)},
        {"glScissorIndexedNV", reinterpret_cast<void*>(glScissorIndexedNV)},
        {"glScissorIndexedvNV", reinterpret_cast<void*>(glScissorIndexedvNV)},
        {"glSelectPerfMonitorCountersAMD", reinterpret_cast<void*>(glSelectPerfMonitorCountersAMD)},
        {"glSetFenceNV", reinterpret_cast<void*>(glSetFenceNV)},
        {"glStartTilingQCOM", reinterpret_cast<void*>(glStartTilingQCOM)},
        {"glStencilFillPathInstancedNV", reinterpret_cast<void*>(glStencilFillPathInstancedNV)},
        {"glStencilFillPathNV", reinterpret_cast<void*>(glStencilFillPathNV)},
        {"glStencilStrokePathInstancedNV", reinterpret_cast<void*>(glStencilStrokePathInstancedNV)},
        {"glStencilStrokePathNV", reinterpret_cast<void*>(glStencilStrokePathNV)},
        {"glStencilThenCoverFillPathInstancedNV", reinterpret_cast<void*>(glStencilThenCoverFillPathInstancedNV)},
        {"glStencilThenCoverFillPathNV", reinterpret_cast<void*>(glStencilThenCoverFillPathNV)},
        {"glStencilThenCoverStrokePathInstancedNV", reinterpret_cast<void*>(glStencilThenCoverStrokePathInstancedNV)},
        {"glStencilThenCoverStrokePathNV", reinterpret_cast<void*>(glStencilThenCoverStrokePathNV)},
        {"glSubpixelPrecisionBiasNV", reinterpret_cast<void*>(glSubpixelPrecisionBiasNV)},
        {"glTestFenceNV", reinterpret_cast<void*>(glTestFenceNV)},
        {"glTexBufferOES", reinterpret_cast<void*>(glTexBufferOES)},
        {"glTexBufferRangeOES", reinterpret_cast<void*>(glTexBufferRangeOES)},
        {"glTexImage3DOES", reinterpret_cast<void*>(glTexImage3DOES)},
        {"glTexPageCommitmentEXT", reinterpret_cast<void*>(glTexPageCommitmentEXT)},
        {"glTexParameterIivOES", reinterpret_cast<void*>(glTexParameterIivOES)},
        {"glTexParameterIuivOES", reinterpret_cast<void*>(glTexParameterIuivOES)},
        {"glTexStorage1DEXT", reinterpret_cast<void*>(glTexStorage1DEXT)},
        {"glTexStorage2DEXT", reinterpret_cast<void*>(glTexStorage2DEXT)},
        {"glTexStorage3DEXT", reinterpret_cast<void*>(glTexStorage3DEXT)},
        {"glTexSubImage3DOES", reinterpret_cast<void*>(glTexSubImage3DOES)},
        {"glTextureStorage1DEXT", reinterpret_cast<void*>(glTextureStorage1DEXT)},
        {"glTextureStorage2DEXT", reinterpret_cast<void*>(glTextureStorage2DEXT)},
        {"glTextureStorage3DEXT", reinterpret_cast<void*>(glTextureStorage3DEXT)},
        {"glTextureViewEXT", reinterpret_cast<void*>(glTextureViewEXT)},
        {"glTextureViewOES", reinterpret_cast<void*>(glTextureViewOES)},
        {"glTransformPathNV", reinterpret_cast<void*>(glTransformPathNV)},
        {"glUniformHandleui64NV", reinterpret_cast<void*>(glUniformHandleui64NV)},
        {"glUniformHandleui64vNV", reinterpret_cast<void*>(glUniformHandleui64vNV)},
        {"glUniformMatrix2x3fvNV", reinterpret_cast<void*>(glUniformMatrix2x3fvNV)},
        {"glUniformMatrix2x4fvNV", reinterpret_cast<void*>(glUniformMatrix2x4fvNV)},
        {"glUniformMatrix3x2fvNV", reinterpret_cast<void*>(glUniformMatrix3x2fvNV)},
        {"glUniformMatrix3x4fvNV", reinterpret_cast<void*>(glUniformMatrix3x4fvNV)},
        {"glUniformMatrix4x2fvNV", reinterpret_cast<void*>(glUniformMatrix4x2fvNV)},
        {"glUniformMatrix4x3fvNV", reinterpret_cast<void*>(glUniformMatrix4x3fvNV)},
        {"glUnmapBufferOES", reinterpret_cast<void*>(glUnmapBufferOES)},
        {"glUseProgramStagesEXT", reinterpret_cast<void*>(glUseProgramStagesEXT)},
        {"glValidateProgramPipelineEXT", reinterpret_cast<void*>(glValidateProgramPipelineEXT)},
        {"glVertexAttribDivisorANGLE", reinterpret_cast<void*>(glVertexAttribDivisorANGLE)},
        {"glVertexAttribDivisorEXT", reinterpret_cast<void*>(glVertexAttribDivisorEXT)},
        {"glVertexAttribDivisorNV", reinterpret_cast<void*>(glVertexAttribDivisorNV)},
        {"glViewportArrayvNV", reinterpret_cast<void*>(glViewportArrayvNV)},
        {"glViewportIndexedfNV", reinterpret_cast<void*>(glViewportIndexedfNV)},
        {"glViewportIndexedfvNV", reinterpret_cast<void*>(glViewportIndexedfvNV)},
        {"glWaitSyncAPPLE", reinterpret_cast<void*>(glWaitSyncAPPLE)},
        {"glWeightPathsNV", reinterpret_cast<void*>(glWeightPathsNV)},
        {"glBlendBarrier", reinterpret_cast<void*>(glBlendBarrier)},
        {"glBlendColor", reinterpret_cast<void*>(glBlendColor)},
        {"glBlendEquation", reinterpret_cast<void*>(glBlendEquation)},
        {"glBlendEquationSeparate", reinterpret_cast<void*>(glBlendEquationSeparate)},
        {"glBlendEquationSeparatei", reinterpret_cast<void*>(glBlendEquationSeparatei)},
        {"glBlendEquationi", reinterpret_cast<void*>(glBlendEquationi)},
        {"glBlendFunc", reinterpret_cast<void*>(glBlendFunc)},
        {"glBlendFuncSeparate", reinterpret_cast<void*>(glBlendFuncSeparate)},
        {"glBlendFuncSeparatei", reinterpret_cast<void*>(glBlendFuncSeparatei)},
        {"glBlendFunci", reinterpret_cast<void*>(glBlendFunci)},
        {"glDepthFunc", reinterpret_cast<void*>(glDepthFunc)},
        {"glSampleCoverage", reinterpret_cast<void*>(glSampleCoverage)},
        {"glSampleMaski", reinterpret_cast<void*>(glSampleMaski)},
        {"glScissor", reinterpret_cast<void*>(glScissor)},
        {"glStencilFunc", reinterpret_cast<void*>(glStencilFunc)},
        {"glStencilFuncSeparate", reinterpret_cast<void*>(glStencilFuncSeparate)},
        {"glStencilOp", reinterpret_cast<void*>(glStencilOp)},
        {"glStencilOpSeparate", reinterpret_cast<void*>(glStencilOpSeparate)},
        {"glBindFramebuffer", reinterpret_cast<void*>(glBindFramebuffer)},
        {"glBindRenderbuffer", reinterpret_cast<void*>(glBindRenderbuffer)},
        {"glBlitFramebuffer", reinterpret_cast<void*>(glBlitFramebuffer)},
        {"glCheckFramebufferStatus", reinterpret_cast<void*>(glCheckFramebufferStatus)},
        {"glClear", reinterpret_cast<void*>(glClear)},
        {"glClearBufferfi", reinterpret_cast<void*>(glClearBufferfi)},
        {"glClearBufferfv", reinterpret_cast<void*>(glClearBufferfv)},
        {"glClearBufferiv", reinterpret_cast<void*>(glClearBufferiv)},
        {"glClearBufferuiv", reinterpret_cast<void*>(glClearBufferuiv)},
        {"glClearColor", reinterpret_cast<void*>(glClearColor)},
        {"glClearDepthf", reinterpret_cast<void*>(glClearDepthf)},
        {"glClearStencil", reinterpret_cast<void*>(glClearStencil)},
        {"glColorMask", reinterpret_cast<void*>(glColorMask)},
        {"glColorMaski", reinterpret_cast<void*>(glColorMaski)},
        {"glDeleteFramebuffers", reinterpret_cast<void*>(glDeleteFramebuffers)},
        {"glDeleteRenderbuffers", reinterpret_cast<void*>(glDeleteRenderbuffers)},
        {"glDepthMask", reinterpret_cast<void*>(glDepthMask)},
        {"glDrawBuffers", reinterpret_cast<void*>(glDrawBuffers)},
        {"glFramebufferParameteri", reinterpret_cast<void*>(glFramebufferParameteri)},
        {"glFramebufferRenderbuffer", reinterpret_cast<void*>(glFramebufferRenderbuffer)},
        {"glFramebufferTexture", reinterpret_cast<void*>(glFramebufferTexture)},
        {"glFramebufferTexture2D", reinterpret_cast<void*>(glFramebufferTexture2D)},
        {"glFramebufferTextureLayer", reinterpret_cast<void*>(glFramebufferTextureLayer)},
        {"glGenFramebuffers", reinterpret_cast<void*>(glGenFramebuffers)},
        {"glGenRenderbuffers", reinterpret_cast<void*>(glGenRenderbuffers)},
        {"glGetFramebufferAttachmentParameteriv", reinterpret_cast<void*>(glGetFramebufferAttachmentParameteriv)},
        {"glGetFramebufferParameteriv", reinterpret_cast<void*>(glGetFramebufferParameteriv)},
        {"glGetRenderbufferParameteriv", reinterpret_cast<void*>(glGetRenderbufferParameteriv)},
        {"glInvalidateFramebuffer", reinterpret_cast<void*>(glInvalidateFramebuffer)},
        {"glInvalidateSubFramebuffer", reinterpret_cast<void*>(glInvalidateSubFramebuffer)},
        {"glIsFramebuffer", reinterpret_cast<void*>(glIsFramebuffer)},
        {"glIsRenderbuffer", reinterpret_cast<void*>(glIsRenderbuffer)},
        {"glReadBuffer", reinterpret_cast<void*>(glReadBuffer)},
        {"glReadPixels", reinterpret_cast<void*>(glReadPixels)},
        {"glReadnPixels", reinterpret_cast<void*>(glReadnPixels)},
        {"glRenderbufferStorage", reinterpret_cast<void*>(glRenderbufferStorage)},
        {"glRenderbufferStorageMultisample", reinterpret_cast<void*>(glRenderbufferStorageMultisample)},
        {"glStencilMask", reinterpret_cast<void*>(glStencilMask)},
        {"glStencilMaskSeparate", reinterpret_cast<void*>(glStencilMaskSeparate)},
        {"glDisable", reinterpret_cast<void*>(glDisable)},
        {"glDisablei", reinterpret_cast<void*>(glDisablei)},
        {"glEnable", reinterpret_cast<void*>(glEnable)},
        {"glEnablei", reinterpret_cast<void*>(glEnablei)},
        {"glFinish", reinterpret_cast<void*>(glFinish)},
        {"glFlush", reinterpret_cast<void*>(glFlush)},
        {"glFlushMappedBufferRange", reinterpret_cast<void*>(glFlushMappedBufferRange)},
        {"glGetError", reinterpret_cast<void*>(glGetError)},
        {"glGetGraphicsResetStatus", reinterpret_cast<void*>(glGetGraphicsResetStatus)},
        {"glHint", reinterpret_cast<void*>(glHint)},
        {"glActiveShaderProgram", reinterpret_cast<void*>(glActiveShaderProgram)},
        {"glAttachShader", reinterpret_cast<void*>(glAttachShader)},
        {"glBindAttribLocation", reinterpret_cast<void*>(glBindAttribLocation)},
        {"glBindProgramPipeline", reinterpret_cast<void*>(glBindProgramPipeline)},
        {"glCompileShader", reinterpret_cast<void*>(glCompileShader)},
        {"glCreateProgram", reinterpret_cast<void*>(glCreateProgram)},
        {"glCreateShader", reinterpret_cast<void*>(glCreateShader)},
        {"glCreateShaderProgramv", reinterpret_cast<void*>(glCreateShaderProgramv)},
        {"glDeleteProgram", reinterpret_cast<void*>(glDeleteProgram)},
        {"glDeleteProgramPipelines", reinterpret_cast<void*>(glDeleteProgramPipelines)},
        {"glDeleteShader", reinterpret_cast<void*>(glDeleteShader)},
        {"glDetachShader", reinterpret_cast<void*>(glDetachShader)},
        {"glDispatchCompute", reinterpret_cast<void*>(glDispatchCompute)},
        {"glDispatchComputeIndirect", reinterpret_cast<void*>(glDispatchComputeIndirect)},
        {"glGenProgramPipelines", reinterpret_cast<void*>(glGenProgramPipelines)},
        {"glGetActiveAttrib", reinterpret_cast<void*>(glGetActiveAttrib)},
        {"glGetActiveUniform", reinterpret_cast<void*>(glGetActiveUniform)},
        {"glGetActiveUniformBlockName", reinterpret_cast<void*>(glGetActiveUniformBlockName)},
        {"glGetActiveUniformBlockiv", reinterpret_cast<void*>(glGetActiveUniformBlockiv)},
        {"glGetActiveUniformsiv", reinterpret_cast<void*>(glGetActiveUniformsiv)},
        {"glGetAttachedShaders", reinterpret_cast<void*>(glGetAttachedShaders)},
        {"glGetAttribLocation", reinterpret_cast<void*>(glGetAttribLocation)},
        {"glGetFragDataLocation", reinterpret_cast<void*>(glGetFragDataLocation)},
        {"glGetProgramBinary", reinterpret_cast<void*>(glGetProgramBinary)},
        {"glGetProgramInfoLog", reinterpret_cast<void*>(glGetProgramInfoLog)},
        {"glGetProgramInterfaceiv", reinterpret_cast<void*>(glGetProgramInterfaceiv)},
        {"glGetProgramPipelineInfoLog", reinterpret_cast<void*>(glGetProgramPipelineInfoLog)},
        {"glGetProgramPipelineiv", reinterpret_cast<void*>(glGetProgramPipelineiv)},
        {"glGetProgramResourceIndex", reinterpret_cast<void*>(glGetProgramResourceIndex)},
        {"glGetProgramResourceLocation", reinterpret_cast<void*>(glGetProgramResourceLocation)},
        {"glGetProgramResourceName", reinterpret_cast<void*>(glGetProgramResourceName)},
        {"glGetProgramResourceiv", reinterpret_cast<void*>(glGetProgramResourceiv)},
        {"glGetProgramiv", reinterpret_cast<void*>(glGetProgramiv)},
        {"glGetShaderInfoLog", reinterpret_cast<void*>(glGetShaderInfoLog)},
        {"glGetShaderPrecisionFormat", reinterpret_cast<void*>(glGetShaderPrecisionFormat)},
        {"glGetShaderSource", reinterpret_cast<void*>(glGetShaderSource)},
        {"glGetShaderiv", reinterpret_cast<void*>(glGetShaderiv)},
        {"glGetUniformBlockIndex", reinterpret_cast<void*>(glGetUniformBlockIndex)},
        {"glGetUniformIndices", reinterpret_cast<void*>(glGetUniformIndices)},
        {"glGetUniformLocation", reinterpret_cast<void*>(glGetUniformLocation)},
        {"glGetUniformfv", reinterpret_cast<void*>(glGetUniformfv)},
        {"glGetUniformiv", reinterpret_cast<void*>(glGetUniformiv)},
        {"glGetUniformuiv", reinterpret_cast<void*>(glGetUniformuiv)},
        {"glGetnUniformfv", reinterpret_cast<void*>(glGetnUniformfv)},
        {"glGetnUniformiv", reinterpret_cast<void*>(glGetnUniformiv)},
        {"glGetnUniformuiv", reinterpret_cast<void*>(glGetnUniformuiv)},
        {"glIsProgram", reinterpret_cast<void*>(glIsProgram)},
        {"glIsProgramPipeline", reinterpret_cast<void*>(glIsProgramPipeline)},
        {"glIsShader", reinterpret_cast<void*>(glIsShader)},
        {"glLinkProgram", reinterpret_cast<void*>(glLinkProgram)},
        {"glMemoryBarrier", reinterpret_cast<void*>(glMemoryBarrier)},
        {"glMemoryBarrierByRegion", reinterpret_cast<void*>(glMemoryBarrierByRegion)},
        {"glProgramBinary", reinterpret_cast<void*>(glProgramBinary)},
        {"glProgramParameteri", reinterpret_cast<void*>(glProgramParameteri)},
        {"glProgramUniform1f", reinterpret_cast<void*>(glProgramUniform1f)},
        {"glProgramUniform1fv", reinterpret_cast<void*>(glProgramUniform1fv)},
        {"glProgramUniform1i", reinterpret_cast<void*>(glProgramUniform1i)},
        {"glProgramUniform1iv", reinterpret_cast<void*>(glProgramUniform1iv)},
        {"glProgramUniform1ui", reinterpret_cast<void*>(glProgramUniform1ui)},
        {"glProgramUniform1uiv", reinterpret_cast<void*>(glProgramUniform1uiv)},
        {"glProgramUniform2f", reinterpret_cast<void*>(glProgramUniform2f)},
        {"glProgramUniform2fv", reinterpret_cast<void*>(glProgramUniform2fv)},
        {"glProgramUniform2i", reinterpret_cast<void*>(glProgramUniform2i)},
        {"glProgramUniform2iv", reinterpret_cast<void*>(glProgramUniform2iv)},
        {"glProgramUniform2ui", reinterpret_cast<void*>(glProgramUniform2ui)},
        {"glProgramUniform2uiv", reinterpret_cast<void*>(glProgramUniform2uiv)},
        {"glProgramUniform3f", reinterpret_cast<void*>(glProgramUniform3f)},
        {"glProgramUniform3fv", reinterpret_cast<void*>(glProgramUniform3fv)},
        {"glProgramUniform3i", reinterpret_cast<void*>(glProgramUniform3i)},
        {"glProgramUniform3iv", reinterpret_cast<void*>(glProgramUniform3iv)},
        {"glProgramUniform3ui", reinterpret_cast<void*>(glProgramUniform3ui)},
        {"glProgramUniform3uiv", reinterpret_cast<void*>(glProgramUniform3uiv)},
        {"glProgramUniform4f", reinterpret_cast<void*>(glProgramUniform4f)},
        {"glProgramUniform4fv", reinterpret_cast<void*>(glProgramUniform4fv)},
        {"glProgramUniform4i", reinterpret_cast<void*>(glProgramUniform4i)},
        {"glProgramUniform4iv", reinterpret_cast<void*>(glProgramUniform4iv)},
        {"glProgramUniform4ui", reinterpret_cast<void*>(glProgramUniform4ui)},
        {"glProgramUniform4uiv", reinterpret_cast<void*>(glProgramUniform4uiv)},
        {"glProgramUniformMatrix2fv", reinterpret_cast<void*>(glProgramUniformMatrix2fv)},
        {"glProgramUniformMatrix2x3fv", reinterpret_cast<void*>(glProgramUniformMatrix2x3fv)},
        {"glProgramUniformMatrix2x4fv", reinterpret_cast<void*>(glProgramUniformMatrix2x4fv)},
        {"glProgramUniformMatrix3fv", reinterpret_cast<void*>(glProgramUniformMatrix3fv)},
        {"glProgramUniformMatrix3x2fv", reinterpret_cast<void*>(glProgramUniformMatrix3x2fv)},
        {"glProgramUniformMatrix3x4fv", reinterpret_cast<void*>(glProgramUniformMatrix3x4fv)},
        {"glProgramUniformMatrix4fv", reinterpret_cast<void*>(glProgramUniformMatrix4fv)},
        {"glProgramUniformMatrix4x2fv", reinterpret_cast<void*>(glProgramUniformMatrix4x2fv)},
        {"glProgramUniformMatrix4x3fv", reinterpret_cast<void*>(glProgramUniformMatrix4x3fv)},
        {"glReleaseShaderCompiler", reinterpret_cast<void*>(glReleaseShaderCompiler)},
        {"glShaderBinary", reinterpret_cast<void*>(glShaderBinary)},
        {"glShaderSource", reinterpret_cast<void*>(glShaderSource)},
        {"glUniform1f", reinterpret_cast<void*>(glUniform1f)},
        {"glUniform1fv", reinterpret_cast<void*>(glUniform1fv)},
        {"glUniform1i", reinterpret_cast<void*>(glUniform1i)},
        {"glUniform1iv", reinterpret_cast<void*>(glUniform1iv)},
        {"glUniform1ui", reinterpret_cast<void*>(glUniform1ui)},
        {"glUniform1uiv", reinterpret_cast<void*>(glUniform1uiv)},
        {"glUniform2f", reinterpret_cast<void*>(glUniform2f)},
        {"glUniform2fv", reinterpret_cast<void*>(glUniform2fv)},
        {"glUniform2i", reinterpret_cast<void*>(glUniform2i)},
        {"glUniform2iv", reinterpret_cast<void*>(glUniform2iv)},
        {"glUniform2ui", reinterpret_cast<void*>(glUniform2ui)},
        {"glUniform2uiv", reinterpret_cast<void*>(glUniform2uiv)},
        {"glUniform3f", reinterpret_cast<void*>(glUniform3f)},
        {"glUniform3fv", reinterpret_cast<void*>(glUniform3fv)},
        {"glUniform3i", reinterpret_cast<void*>(glUniform3i)},
        {"glUniform3iv", reinterpret_cast<void*>(glUniform3iv)},
        {"glUniform3ui", reinterpret_cast<void*>(glUniform3ui)},
        {"glUniform3uiv", reinterpret_cast<void*>(glUniform3uiv)},
        {"glUniform4f", reinterpret_cast<void*>(glUniform4f)},
        {"glUniform4fv", reinterpret_cast<void*>(glUniform4fv)},
        {"glUniform4i", reinterpret_cast<void*>(glUniform4i)},
        {"glUniform4iv", reinterpret_cast<void*>(glUniform4iv)},
        {"glUniform4ui", reinterpret_cast<void*>(glUniform4ui)},
        {"glUniform4uiv", reinterpret_cast<void*>(glUniform4uiv)},
        {"glUniformBlockBinding", reinterpret_cast<void*>(glUniformBlockBinding)},
        {"glUniformMatrix2fv", reinterpret_cast<void*>(glUniformMatrix2fv)},
        {"glUniformMatrix2x3fv", reinterpret_cast<void*>(glUniformMatrix2x3fv)},
        {"glUniformMatrix2x4fv", reinterpret_cast<void*>(glUniformMatrix2x4fv)},
        {"glUniformMatrix3fv", reinterpret_cast<void*>(glUniformMatrix3fv)},
        {"glUniformMatrix3x2fv", reinterpret_cast<void*>(glUniformMatrix3x2fv)},
        {"glUniformMatrix3x4fv", reinterpret_cast<void*>(glUniformMatrix3x4fv)},
        {"glUniformMatrix4fv", reinterpret_cast<void*>(glUniformMatrix4fv)},
        {"glUniformMatrix4x2fv", reinterpret_cast<void*>(glUniformMatrix4x2fv)},
        {"glUniformMatrix4x3fv", reinterpret_cast<void*>(glUniformMatrix4x3fv)},
        {"glUseProgram", reinterpret_cast<void*>(glUseProgram)},
        {"glUseProgramStages", reinterpret_cast<void*>(glUseProgramStages)},
        {"glValidateProgram", reinterpret_cast<void*>(glValidateProgram)},
        {"glValidateProgramPipeline", reinterpret_cast<void*>(glValidateProgramPipeline)},
        {"glCullFace", reinterpret_cast<void*>(glCullFace)},
        {"glDepthRangef", reinterpret_cast<void*>(glDepthRangef)},
        {"glFrontFace", reinterpret_cast<void*>(glFrontFace)},
        {"glGetMultisamplefv", reinterpret_cast<void*>(glGetMultisamplefv)},
        {"glLineWidth", reinterpret_cast<void*>(glLineWidth)},
        {"glMinSampleShading", reinterpret_cast<void*>(glMinSampleShading)},
        {"glPolygonOffset", reinterpret_cast<void*>(glPolygonOffset)},
        {"glViewport", reinterpret_cast<void*>(glViewport)},
        {"glGetBooleani_v", reinterpret_cast<void*>(glGetBooleani_v)},
        {"glGetBooleanv", reinterpret_cast<void*>(glGetBooleanv)},
        {"glGetFloatv", reinterpret_cast<void*>(glGetFloatv)},
        {"glGetInteger64i_v", reinterpret_cast<void*>(glGetInteger64i_v)},
        {"glGetInteger64v", reinterpret_cast<void*>(glGetInteger64v)},
        {"glGetIntegeri_v", reinterpret_cast<void*>(glGetIntegeri_v)},
        {"glGetIntegerv", reinterpret_cast<void*>(glGetIntegerv)},
        {"glGetInternalformativ", reinterpret_cast<void*>(glGetInternalformativ)},
        {"glGetString", reinterpret_cast<void*>(glGetString)},
        {"glGetStringi", reinterpret_cast<void*>(glGetStringi)},
        {"glIsEnabled", reinterpret_cast<void*>(glIsEnabled)},
        {"glIsEnabledi", reinterpret_cast<void*>(glIsEnabledi)},
        {"glClientWaitSync", reinterpret_cast<void*>(glClientWaitSync)},
        {"glDeleteSync", reinterpret_cast<void*>(glDeleteSync)},
        {"glFenceSync", reinterpret_cast<void*>(glFenceSync)},
        {"glGetSynciv", reinterpret_cast<void*>(glGetSynciv)},
        {"glIsSync", reinterpret_cast<void*>(glIsSync)},
        {"glWaitSync", reinterpret_cast<void*>(glWaitSync)},
        {"glActiveTexture", reinterpret_cast<void*>(glActiveTexture)},
        {"glBindImageTexture", reinterpret_cast<void*>(glBindImageTexture)},
        {"glBindSampler", reinterpret_cast<void*>(glBindSampler)},
        {"glBindTexture", reinterpret_cast<void*>(glBindTexture)},
        {"glCompressedTexImage2D", reinterpret_cast<void*>(glCompressedTexImage2D)},
        {"glCompressedTexImage3D", reinterpret_cast<void*>(glCompressedTexImage3D)},
        {"glCompressedTexSubImage2D", reinterpret_cast<void*>(glCompressedTexSubImage2D)},
        {"glCompressedTexSubImage3D", reinterpret_cast<void*>(glCompressedTexSubImage3D)},
        {"glCopyImageSubData", reinterpret_cast<void*>(glCopyImageSubData)},
        {"glCopyTexImage2D", reinterpret_cast<void*>(glCopyTexImage2D)},
        {"glCopyTexSubImage2D", reinterpret_cast<void*>(glCopyTexSubImage2D)},
        {"glCopyTexSubImage3D", reinterpret_cast<void*>(glCopyTexSubImage3D)},
        {"glDeleteSamplers", reinterpret_cast<void*>(glDeleteSamplers)},
        {"glDeleteTextures", reinterpret_cast<void*>(glDeleteTextures)},
        {"glGenSamplers", reinterpret_cast<void*>(glGenSamplers)},
        {"glGenTextures", reinterpret_cast<void*>(glGenTextures)},
        {"glGenerateMipmap", reinterpret_cast<void*>(glGenerateMipmap)},
        {"glGetSamplerParameterIiv", reinterpret_cast<void*>(glGetSamplerParameterIiv)},
        {"glGetSamplerParameterIuiv", reinterpret_cast<void*>(glGetSamplerParameterIuiv)},
        {"glGetSamplerParameterfv", reinterpret_cast<void*>(glGetSamplerParameterfv)},
        {"glGetSamplerParameteriv", reinterpret_cast<void*>(glGetSamplerParameteriv)},
        {"glGetTexLevelParameterfv", reinterpret_cast<void*>(glGetTexLevelParameterfv)},
        {"glGetTexLevelParameteriv", reinterpret_cast<void*>(glGetTexLevelParameteriv)},
        {"glGetTexParameterIiv", reinterpret_cast<void*>(glGetTexParameterIiv)},
        {"glGetTexParameterIuiv", reinterpret_cast<void*>(glGetTexParameterIuiv)},
        {"glGetTexParameterfv", reinterpret_cast<void*>(glGetTexParameterfv)},
        {"glGetTexParameteriv", reinterpret_cast<void*>(glGetTexParameteriv)},
        {"glIsSampler", reinterpret_cast<void*>(glIsSampler)},
        {"glIsTexture", reinterpret_cast<void*>(glIsTexture)},
        {"glPixelStorei", reinterpret_cast<void*>(glPixelStorei)},
        {"glSamplerParameterIiv", reinterpret_cast<void*>(glSamplerParameterIiv)},
        {"glSamplerParameterIuiv", reinterpret_cast<void*>(glSamplerParameterIuiv)},
        {"glSamplerParameterf", reinterpret_cast<void*>(glSamplerParameterf)},
        {"glSamplerParameterfv", reinterpret_cast<void*>(glSamplerParameterfv)},
        {"glSamplerParameteri", reinterpret_cast<void*>(glSamplerParameteri)},
        {"glSamplerParameteriv", reinterpret_cast<void*>(glSamplerParameteriv)},
        {"glTexBuffer", reinterpret_cast<void*>(glTexBuffer)},
        {"glTexBufferRange", reinterpret_cast<void*>(glTexBufferRange)},
        {"glTexImage2D", reinterpret_cast<void*>(glTexImage2D)},
        {"glTexImage3D", reinterpret_cast<void*>(glTexImage3D)},
        {"glTexParameterIiv", reinterpret_cast<void*>(glTexParameterIiv)},
        {"glTexParameterIuiv", reinterpret_cast<void*>(glTexParameterIuiv)},
        {"glTexParameterf", reinterpret_cast<void*>(glTexParameterf)},
        {"glTexParameterfv", reinterpret_cast<void*>(glTexParameterfv)},
        {"glTexParameteri", reinterpret_cast<void*>(glTexParameteri)},
        {"glTexParameteriv", reinterpret_cast<void*>(glTexParameteriv)},
        {"glTexStorage2D", reinterpret_cast<void*>(glTexStorage2D)},
        {"glTexStorage2DMultisample", reinterpret_cast<void*>(glTexStorage2DMultisample)},
        {"glTexStorage3D", reinterpret_cast<void*>(glTexStorage3D)},
        {"glTexStorage3DMultisample", reinterpret_cast<void*>(glTexStorage3DMultisample)},
        {"glTexSubImage2D", reinterpret_cast<void*>(glTexSubImage2D)},
        {"glTexSubImage3D", reinterpret_cast<void*>(glTexSubImage3D)},
        {"glBeginTransformFeedback", reinterpret_cast<void*>(glBeginTransformFeedback)},
        {"glBindTransformFeedback", reinterpret_cast<void*>(glBindTransformFeedback)},
        {"glDeleteTransformFeedbacks", reinterpret_cast<void*>(glDeleteTransformFeedbacks)},
        {"glEndTransformFeedback", reinterpret_cast<void*>(glEndTransformFeedback)},
        {"glGenTransformFeedbacks", reinterpret_cast<void*>(glGenTransformFeedbacks)},
        {"glGetTransformFeedbackVarying", reinterpret_cast<void*>(glGetTransformFeedbackVarying)},
        {"glIsTransformFeedback", reinterpret_cast<void*>(glIsTransformFeedback)},
        {"glPauseTransformFeedback", reinterpret_cast<void*>(glPauseTransformFeedback)},
        {"glResumeTransformFeedback", reinterpret_cast<void*>(glResumeTransformFeedback)},
        {"glTransformFeedbackVaryings", reinterpret_cast<void*>(glTransformFeedbackVaryings)},
        {"glBindVertexArray", reinterpret_cast<void*>(glBindVertexArray)},
        {"glBindVertexBuffer", reinterpret_cast<void*>(glBindVertexBuffer)},
        {"glDeleteVertexArrays", reinterpret_cast<void*>(glDeleteVertexArrays)},
        {"glDisableVertexAttribArray", reinterpret_cast<void*>(glDisableVertexAttribArray)},
        {"glEnableVertexAttribArray", reinterpret_cast<void*>(glEnableVertexAttribArray)},
        {"glGenVertexArrays", reinterpret_cast<void*>(glGenVertexArrays)},
        {"glGetVertexAttribIiv", reinterpret_cast<void*>(glGetVertexAttribIiv)},
        {"glGetVertexAttribIuiv", reinterpret_cast<void*>(glGetVertexAttribIuiv)},
        {"glGetVertexAttribPointerv", reinterpret_cast<void*>(glGetVertexAttribPointerv)},
        {"glGetVertexAttribfv", reinterpret_cast<void*>(glGetVertexAttribfv)},
        {"glGetVertexAttribiv", reinterpret_cast<void*>(glGetVertexAttribiv)},
        {"glIsVertexArray", reinterpret_cast<void*>(glIsVertexArray)},
        {"glVertexAttrib1f", reinterpret_cast<void*>(glVertexAttrib1f)},
        {"glVertexAttrib1fv", reinterpret_cast<void*>(glVertexAttrib1fv)},
        {"glVertexAttrib2f", reinterpret_cast<void*>(glVertexAttrib2f)},
        {"glVertexAttrib2fv", reinterpret_cast<void*>(glVertexAttrib2fv)},
        {"glVertexAttrib3f", reinterpret_cast<void*>(glVertexAttrib3f)},
        {"glVertexAttrib3fv", reinterpret_cast<void*>(glVertexAttrib3fv)},
        {"glVertexAttrib4f", reinterpret_cast<void*>(glVertexAttrib4f)},
        {"glVertexAttrib4fv", reinterpret_cast<void*>(glVertexAttrib4fv)},
        {"glVertexAttribBinding", reinterpret_cast<void*>(glVertexAttribBinding)},
        {"glVertexAttribDivisor", reinterpret_cast<void*>(glVertexAttribDivisor)},
        {"glVertexAttribFormat", reinterpret_cast<void*>(glVertexAttribFormat)},
        {"glVertexAttribI4i", reinterpret_cast<void*>(glVertexAttribI4i)},
        {"glVertexAttribI4iv", reinterpret_cast<void*>(glVertexAttribI4iv)},
        {"glVertexAttribI4ui", reinterpret_cast<void*>(glVertexAttribI4ui)},
        {"glVertexAttribI4uiv", reinterpret_cast<void*>(glVertexAttribI4uiv)},
        {"glVertexAttribIFormat", reinterpret_cast<void*>(glVertexAttribIFormat)},
        {"glVertexAttribIPointer", reinterpret_cast<void*>(glVertexAttribIPointer)},
        {"glVertexAttribPointer", reinterpret_cast<void*>(glVertexAttribPointer)},
        {"glVertexBindingDivisor", reinterpret_cast<void*>(glVertexBindingDivisor)},
        {"eglInitialize", reinterpret_cast<void*>(eglInitialize)},
        {"eglCreateContext", reinterpret_cast<void*>(eglCreateContext)},
        {"eglMakeCurrent", reinterpret_cast<void*>(eglMakeCurrent)},
        {"eglSwapBuffers", reinterpret_cast<void*>(eglSwapBuffers)},
        {"eglSwapBuffersWithDamageKHR", reinterpret_cast<void*>(eglSwapBuffersWithDamageKHR)},
        {"eglQuerySurface", reinterpret_cast<void*>(eglQuerySurface)},
        {"eglQueryContext", reinterpret_cast<void*>(eglQueryContext)},
        {"eglChooseConfig", reinterpret_cast<void*>(eglChooseConfig)},
        {"eglGetConfigAttrib", reinterpret_cast<void*>(eglGetConfigAttrib)},
        {"glXCreateContext", reinterpret_cast<void*>(glXCreateContext)},
        {"glXCreateNewContext", reinterpret_cast<void*>(glXCreateNewContext)},
        {"glXMakeContextCurrent", reinterpret_cast<void*>(glXMakeContextCurrent)},
        {"glXMakeCurrent", reinterpret_cast<void*>(glXMakeCurrent)},
        {"glXSwapBuffers", reinterpret_cast<void*>(glXSwapBuffers)},
        {"glXQueryDrawable", reinterpret_cast<void*>(glXQueryDrawable)},
        {"wglCreateContext", reinterpret_cast<void*>(wglCreateContext)},
        {"wglCreateContextAttribsARB", reinterpret_cast<void*>(wglCreateContextAttribsARB)},
        {"wglMakeCurrent", reinterpret_cast<void*>(wglMakeCurrent)},
        {"wglSwapBuffers", reinterpret_cast<void*>(wglSwapBuffers)},
        {"CGLCreateContext", reinterpret_cast<void*>(CGLCreateContext)},
        {"CGLSetCurrentContext", reinterpret_cast<void*>(CGLSetCurrentContext)},
        {"CGLGetSurface", reinterpret_cast<void*>(CGLGetSurface)},
        {"CGSGetSurfaceBounds", reinterpret_cast<void*>(CGSGetSurfaceBounds)},
        {"CGLFlushDrawable", reinterpret_cast<void*>(CGLFlushDrawable)},
        {"glGetQueryObjecti64v", reinterpret_cast<void*>(glGetQueryObjecti64v)},
        {"glGetQueryObjectui64v", reinterpret_cast<void*>(glGetQueryObjectui64v)},
        {"glAlphaFunc", reinterpret_cast<void*>(glAlphaFunc)},
        {"glAlphaFuncx", reinterpret_cast<void*>(glAlphaFuncx)},
        {"glAlphaFuncxOES", reinterpret_cast<void*>(glAlphaFuncxOES)},
        {"glBindFramebufferOES", reinterpret_cast<void*>(glBindFramebufferOES)},
        {"glBindRenderbufferOES", reinterpret_cast<void*>(glBindRenderbufferOES)},
        {"glBlendEquationOES", reinterpret_cast<void*>(glBlendEquationOES)},
        {"glBlendEquationSeparateOES", reinterpret_cast<void*>(glBlendEquationSeparateOES)},
        {"glBlendFuncSeparateOES", reinterpret_cast<void*>(glBlendFuncSeparateOES)},
        {"glCheckFramebufferStatusOES", reinterpret_cast<void*>(glCheckFramebufferStatusOES)},
        {"glClearColorx", reinterpret_cast<void*>(glClearColorx)},
        {"glClearColorxOES", reinterpret_cast<void*>(glClearColorxOES)},
        {"glClearDepthfOES", reinterpret_cast<void*>(glClearDepthfOES)},
        {"glClearDepthx", reinterpret_cast<void*>(glClearDepthx)},
        {"glClearDepthxOES", reinterpret_cast<void*>(glClearDepthxOES)},
        {"glClientActiveTexture", reinterpret_cast<void*>(glClientActiveTexture)},
        {"glClipPlanef", reinterpret_cast<void*>(glClipPlanef)},
        {"glClipPlanefIMG", reinterpret_cast<void*>(glClipPlanefIMG)},
        {"glClipPlanefOES", reinterpret_cast<void*>(glClipPlanefOES)},
        {"glClipPlanex", reinterpret_cast<void*>(glClipPlanex)},
        {"glClipPlanexIMG", reinterpret_cast<void*>(glClipPlanexIMG)},
        {"glClipPlanexOES", reinterpret_cast<void*>(glClipPlanexOES)},
        {"glColor4f", reinterpret_cast<void*>(glColor4f)},
        {"glColor4ub", reinterpret_cast<void*>(glColor4ub)},
        {"glColor4x", reinterpret_cast<void*>(glColor4x)},
        {"glColor4xOES", reinterpret_cast<void*>(glColor4xOES)},
        {"glColorPointer", reinterpret_cast<void*>(glColorPointer)},
        {"glCurrentPaletteMatrixOES", reinterpret_cast<void*>(glCurrentPaletteMatrixOES)},
        {"glDeleteFramebuffersOES", reinterpret_cast<void*>(glDeleteFramebuffersOES)},
        {"glDeleteRenderbuffersOES", reinterpret_cast<void*>(glDeleteRenderbuffersOES)},
        {"glDepthRangefOES", reinterpret_cast<void*>(glDepthRangefOES)},
        {"glDepthRangex", reinterpret_cast<void*>(glDepthRangex)},
        {"glDepthRangexOES", reinterpret_cast<void*>(glDepthRangexOES)},
        {"glDisableClientState", reinterpret_cast<void*>(glDisableClientState)},
        {"glDrawTexfOES", reinterpret_cast<void*>(glDrawTexfOES)},
        {"glDrawTexfvOES", reinterpret_cast<void*>(glDrawTexfvOES)},
        {"glDrawTexiOES", reinterpret_cast<void*>(glDrawTexiOES)},
        {"glDrawTexivOES", reinterpret_cast<void*>(glDrawTexivOES)},
        {"glDrawTexsOES", reinterpret_cast<void*>(glDrawTexsOES)},
        {"glDrawTexsvOES", reinterpret_cast<void*>(glDrawTexsvOES)},
        {"glDrawTexxOES", reinterpret_cast<void*>(glDrawTexxOES)},
        {"glDrawTexxvOES", reinterpret_cast<void*>(glDrawTexxvOES)},
        {"glEnableClientState", reinterpret_cast<void*>(glEnableClientState)},
        {"glFogf", reinterpret_cast<void*>(glFogf)},
        {"glFogfv", reinterpret_cast<void*>(glFogfv)},
        {"glFogx", reinterpret_cast<void*>(glFogx)},
        {"glFogxOES", reinterpret_cast<void*>(glFogxOES)},
        {"glFogxv", reinterpret_cast<void*>(glFogxv)},
        {"glFogxvOES", reinterpret_cast<void*>(glFogxvOES)},
        {"glFramebufferRenderbufferOES", reinterpret_cast<void*>(glFramebufferRenderbufferOES)},
        {"glFramebufferTexture2DOES", reinterpret_cast<void*>(glFramebufferTexture2DOES)},
        {"glFrustumf", reinterpret_cast<void*>(glFrustumf)},
        {"glFrustumfOES", reinterpret_cast<void*>(glFrustumfOES)},
        {"glFrustumx", reinterpret_cast<void*>(glFrustumx)},
        {"glFrustumxOES", reinterpret_cast<void*>(glFrustumxOES)},
        {"glGenFramebuffersOES", reinterpret_cast<void*>(glGenFramebuffersOES)},
        {"glGenRenderbuffersOES", reinterpret_cast<void*>(glGenRenderbuffersOES)},
        {"glGenerateMipmapOES", reinterpret_cast<void*>(glGenerateMipmapOES)},
        {"glGetClipPlanef", reinterpret_cast<void*>(glGetClipPlanef)},
        {"glGetClipPlanefOES", reinterpret_cast<void*>(glGetClipPlanefOES)},
        {"glGetClipPlanex", reinterpret_cast<void*>(glGetClipPlanex)},
        {"glGetClipPlanexOES", reinterpret_cast<void*>(glGetClipPlanexOES)},
        {"glGetFixedv", reinterpret_cast<void*>(glGetFixedv)},
        {"glGetFixedvOES", reinterpret_cast<void*>(glGetFixedvOES)},
        {"glGetFramebufferAttachmentParameterivOES", reinterpret_cast<void*>(glGetFramebufferAttachmentParameterivOES)},
        {"glGetLightfv", reinterpret_cast<void*>(glGetLightfv)},
        {"glGetLightxv", reinterpret_cast<void*>(glGetLightxv)},
        {"glGetLightxvOES", reinterpret_cast<void*>(glGetLightxvOES)},
        {"glGetMaterialfv", reinterpret_cast<void*>(glGetMaterialfv)},
        {"glGetMaterialxv", reinterpret_cast<void*>(glGetMaterialxv)},
        {"glGetMaterialxvOES", reinterpret_cast<void*>(glGetMaterialxvOES)},
        {"glGetRenderbufferParameterivOES", reinterpret_cast<void*>(glGetRenderbufferParameterivOES)},
        {"glGetTexEnvfv", reinterpret_cast<void*>(glGetTexEnvfv)},
        {"glGetTexEnviv", reinterpret_cast<void*>(glGetTexEnviv)},
        {"glGetTexEnvxv", reinterpret_cast<void*>(glGetTexEnvxv)},
        {"glGetTexEnvxvOES", reinterpret_cast<void*>(glGetTexEnvxvOES)},
        {"glGetTexGenfvOES", reinterpret_cast<void*>(glGetTexGenfvOES)},
        {"glGetTexGenivOES", reinterpret_cast<void*>(glGetTexGenivOES)},
        {"glGetTexGenxvOES", reinterpret_cast<void*>(glGetTexGenxvOES)},
        {"glGetTexParameterxv", reinterpret_cast<void*>(glGetTexParameterxv)},
        {"glGetTexParameterxvOES", reinterpret_cast<void*>(glGetTexParameterxvOES)},
        {"glIsFramebufferOES", reinterpret_cast<void*>(glIsFramebufferOES)},
        {"glIsRenderbufferOES", reinterpret_cast<void*>(glIsRenderbufferOES)},
        {"glLightModelf", reinterpret_cast<void*>(glLightModelf)},
        {"glLightModelfv", reinterpret_cast<void*>(glLightModelfv)},
        {"glLightModelx", reinterpret_cast<void*>(glLightModelx)},
        {"glLightModelxOES", reinterpret_cast<void*>(glLightModelxOES)},
        {"glLightModelxv", reinterpret_cast<void*>(glLightModelxv)},
        {"glLightModelxvOES", reinterpret_cast<void*>(glLightModelxvOES)},
        {"glLightf", reinterpret_cast<void*>(glLightf)},
        {"glLightfv", reinterpret_cast<void*>(glLightfv)},
        {"glLightx", reinterpret_cast<void*>(glLightx)},
        {"glLightxOES", reinterpret_cast<void*>(glLightxOES)},
        {"glLightxv", reinterpret_cast<void*>(glLightxv)},
        {"glLightxvOES", reinterpret_cast<void*>(glLightxvOES)},
        {"glLineWidthx", reinterpret_cast<void*>(glLineWidthx)},
        {"glLineWidthxOES", reinterpret_cast<void*>(glLineWidthxOES)},
        {"glLoadIdentity", reinterpret_cast<void*>(glLoadIdentity)},
        {"glLoadMatrixf", reinterpret_cast<void*>(glLoadMatrixf)},
        {"glLoadMatrixx", reinterpret_cast<void*>(glLoadMatrixx)},
        {"glLoadMatrixxOES", reinterpret_cast<void*>(glLoadMatrixxOES)},
        {"glLoadPaletteFromModelViewMatrixOES", reinterpret_cast<void*>(glLoadPaletteFromModelViewMatrixOES)},
        {"glLogicOp", reinterpret_cast<void*>(glLogicOp)},
        {"glMaterialf", reinterpret_cast<void*>(glMaterialf)},
        {"glMaterialfv", reinterpret_cast<void*>(glMaterialfv)},
        {"glMaterialx", reinterpret_cast<void*>(glMaterialx)},
        {"glMaterialxOES", reinterpret_cast<void*>(glMaterialxOES)},
        {"glMaterialxv", reinterpret_cast<void*>(glMaterialxv)},
        {"glMaterialxvOES", reinterpret_cast<void*>(glMaterialxvOES)},
        {"glMatrixIndexPointerOES", reinterpret_cast<void*>(glMatrixIndexPointerOES)},
        {"glMatrixMode", reinterpret_cast<void*>(glMatrixMode)},
        {"glMultMatrixf", reinterpret_cast<void*>(glMultMatrixf)},
        {"glMultMatrixx", reinterpret_cast<void*>(glMultMatrixx)},
        {"glMultMatrixxOES", reinterpret_cast<void*>(glMultMatrixxOES)},
        {"glMultiTexCoord4f", reinterpret_cast<void*>(glMultiTexCoord4f)},
        {"glMultiTexCoord4x", reinterpret_cast<void*>(glMultiTexCoord4x)},
        {"glMultiTexCoord4xOES", reinterpret_cast<void*>(glMultiTexCoord4xOES)},
        {"glNormal3f", reinterpret_cast<void*>(glNormal3f)},
        {"glNormal3x", reinterpret_cast<void*>(glNormal3x)},
        {"glNormal3xOES", reinterpret_cast<void*>(glNormal3xOES)},
        {"glNormalPointer", reinterpret_cast<void*>(glNormalPointer)},
        {"glOrthof", reinterpret_cast<void*>(glOrthof)},
        {"glOrthofOES", reinterpret_cast<void*>(glOrthofOES)},
        {"glOrthox", reinterpret_cast<void*>(glOrthox)},
        {"glOrthoxOES", reinterpret_cast<void*>(glOrthoxOES)},
        {"glPointParameterf", reinterpret_cast<void*>(glPointParameterf)},
        {"glPointParameterfv", reinterpret_cast<void*>(glPointParameterfv)},
        {"glPointParameterx", reinterpret_cast<void*>(glPointParameterx)},
        {"glPointParameterxOES", reinterpret_cast<void*>(glPointParameterxOES)},
        {"glPointParameterxv", reinterpret_cast<void*>(glPointParameterxv)},
        {"glPointParameterxvOES", reinterpret_cast<void*>(glPointParameterxvOES)},
        {"glPointSize", reinterpret_cast<void*>(glPointSize)},
        {"glPointSizePointerOES", reinterpret_cast<void*>(glPointSizePointerOES)},
        {"glPointSizex", reinterpret_cast<void*>(glPointSizex)},
        {"glPointSizexOES", reinterpret_cast<void*>(glPointSizexOES)},
        {"glPolygonOffsetx", reinterpret_cast<void*>(glPolygonOffsetx)},
        {"glPolygonOffsetxOES", reinterpret_cast<void*>(glPolygonOffsetxOES)},
        {"glPopMatrix", reinterpret_cast<void*>(glPopMatrix)},
        {"glPushMatrix", reinterpret_cast<void*>(glPushMatrix)},
        {"glQueryMatrixxOES", reinterpret_cast<void*>(glQueryMatrixxOES)},
        {"glRenderbufferStorageOES", reinterpret_cast<void*>(glRenderbufferStorageOES)},
        {"glRotatef", reinterpret_cast<void*>(glRotatef)},
        {"glRotatex", reinterpret_cast<void*>(glRotatex)},
        {"glRotatexOES", reinterpret_cast<void*>(glRotatexOES)},
        {"glSampleCoveragex", reinterpret_cast<void*>(glSampleCoveragex)},
        {"glSampleCoveragexOES", reinterpret_cast<void*>(glSampleCoveragexOES)},
        {"glScalef", reinterpret_cast<void*>(glScalef)},
        {"glScalex", reinterpret_cast<void*>(glScalex)},
        {"glScalexOES", reinterpret_cast<void*>(glScalexOES)},
        {"glShadeModel", reinterpret_cast<void*>(glShadeModel)},
        {"glTexCoordPointer", reinterpret_cast<void*>(glTexCoordPointer)},
        {"glTexEnvf", reinterpret_cast<void*>(glTexEnvf)},
        {"glTexEnvfv", reinterpret_cast<void*>(glTexEnvfv)},
        {"glTexEnvi", reinterpret_cast<void*>(glTexEnvi)},
        {"glTexEnviv", reinterpret_cast<void*>(glTexEnviv)},
        {"glTexEnvx", reinterpret_cast<void*>(glTexEnvx)},
        {"glTexEnvxOES", reinterpret_cast<void*>(glTexEnvxOES)},
        {"glTexEnvxv", reinterpret_cast<void*>(glTexEnvxv)},
        {"glTexEnvxvOES", reinterpret_cast<void*>(glTexEnvxvOES)},
        {"glTexGenfOES", reinterpret_cast<void*>(glTexGenfOES)},
        {"glTexGenfvOES", reinterpret_cast<void*>(glTexGenfvOES)},
        {"glTexGeniOES", reinterpret_cast<void*>(glTexGeniOES)},
        {"glTexGenivOES", reinterpret_cast<void*>(glTexGenivOES)},
        {"glTexGenxOES", reinterpret_cast<void*>(glTexGenxOES)},
        {"glTexGenxvOES", reinterpret_cast<void*>(glTexGenxvOES)},
        {"glTexParameterx", reinterpret_cast<void*>(glTexParameterx)},
        {"glTexParameterxOES", reinterpret_cast<void*>(glTexParameterxOES)},
        {"glTexParameterxv", reinterpret_cast<void*>(glTexParameterxv)},
        {"glTexParameterxvOES", reinterpret_cast<void*>(glTexParameterxvOES)},
        {"glTranslatef", reinterpret_cast<void*>(glTranslatef)},
        {"glTranslatex", reinterpret_cast<void*>(glTranslatex)},
        {"glTranslatexOES", reinterpret_cast<void*>(glTranslatexOES)},
        {"glVertexPointer", reinterpret_cast<void*>(glVertexPointer)},
        {"glWeightPointerOES", reinterpret_cast<void*>(glWeightPointerOES)},
        {"glColorPointerBounds", reinterpret_cast<void*>(glColorPointerBounds)},
        {"glNormalPointerBounds", reinterpret_cast<void*>(glNormalPointerBounds)},
        {"glTexCoordPointerBounds", reinterpret_cast<void*>(glTexCoordPointerBounds)},
        {"glVertexPointerBounds", reinterpret_cast<void*>(glVertexPointerBounds)},
        {"glPointSizePointerOESBounds", reinterpret_cast<void*>(glPointSizePointerOESBounds)},
        {"glMatrixIndexPointerOESBounds", reinterpret_cast<void*>(glMatrixIndexPointerOESBounds)},
        {"glWeightPointerOESBounds", reinterpret_cast<void*>(glWeightPointerOESBounds)},
        {"eglGetProcAddress",    reinterpret_cast<void*>(eglGetProcAddress)},
        {"wglGetProcAddress",    reinterpret_cast<void*>(wglGetProcAddress)},
        {"glXGetProcAddress",    reinterpret_cast<void*>(glXGetProcAddress)},
        {"glXGetProcAddressARB", reinterpret_cast<void*>(glXGetProcAddressARB)},
        {NULL, NULL}
    };
} // namespace gapii
namespace {

void* STDCALL GetSpyProcAddress(const char* name) {
    if (void* proc = Spy::get()->LookupSymbol(name)) {
        return proc;
    } else {
        GAPID_WARNING("%s will NOT be captured.", name);
        return gapic::GetGfxProcAddress(name, true);
    }
}

} // anonymous namespace

extern "C" {

EXPORT void STDCALL glBlendBarrierKHR() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendBarrierKHR()");
    if (s->enter("glBlendBarrierKHR")) {
        s->glBlendBarrierKHR();
        s->exit();
        GAPID_DEBUG("glBlendBarrierKHR() -- done");
    } else {
        GAPID_INFO("glBlendBarrierKHR at %p: GAPII re-entered. Just invoking imported function at %p", glBlendBarrierKHR, s->GlesSpy::imports().glBlendBarrierKHR);
        s->GlesSpy::imports().glBlendBarrierKHR();
        GAPID_DEBUG("glBlendBarrierKHR() -- done");
    }
}
EXPORT void STDCALL glBlendEquationSeparateiEXT(DrawBufferIndex buf, uint32_t modeRGB, uint32_t modeAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationSeparateiEXT(%" PRIu32 ", %u, %u)", buf, modeRGB, modeAlpha);
    if (s->enter("glBlendEquationSeparateiEXT")) {
        s->glBlendEquationSeparateiEXT(buf, modeRGB, modeAlpha);
        s->exit();
        GAPID_DEBUG("glBlendEquationSeparateiEXT() -- done");
    } else {
        GAPID_INFO("glBlendEquationSeparateiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationSeparateiEXT, s->GlesSpy::imports().glBlendEquationSeparateiEXT);
        s->GlesSpy::imports().glBlendEquationSeparateiEXT(buf, modeRGB, modeAlpha);
        GAPID_DEBUG("glBlendEquationSeparateiEXT() -- done");
    }
}
EXPORT void STDCALL glBlendEquationiEXT(DrawBufferIndex buf, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationiEXT(%" PRIu32 ", %u)", buf, mode);
    if (s->enter("glBlendEquationiEXT")) {
        s->glBlendEquationiEXT(buf, mode);
        s->exit();
        GAPID_DEBUG("glBlendEquationiEXT() -- done");
    } else {
        GAPID_INFO("glBlendEquationiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationiEXT, s->GlesSpy::imports().glBlendEquationiEXT);
        s->GlesSpy::imports().glBlendEquationiEXT(buf, mode);
        GAPID_DEBUG("glBlendEquationiEXT() -- done");
    }
}
EXPORT void STDCALL glBlendFuncSeparateiEXT(DrawBufferIndex buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFuncSeparateiEXT(%" PRIu32 ", %u, %u, %u, %u)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
    if (s->enter("glBlendFuncSeparateiEXT")) {
        s->glBlendFuncSeparateiEXT(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
        s->exit();
        GAPID_DEBUG("glBlendFuncSeparateiEXT() -- done");
    } else {
        GAPID_INFO("glBlendFuncSeparateiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFuncSeparateiEXT, s->GlesSpy::imports().glBlendFuncSeparateiEXT);
        s->GlesSpy::imports().glBlendFuncSeparateiEXT(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
        GAPID_DEBUG("glBlendFuncSeparateiEXT() -- done");
    }
}
EXPORT void STDCALL glBlendFunciEXT(DrawBufferIndex buf, uint32_t src, uint32_t dst) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFunciEXT(%" PRIu32 ", %u, %u)", buf, src, dst);
    if (s->enter("glBlendFunciEXT")) {
        s->glBlendFunciEXT(buf, src, dst);
        s->exit();
        GAPID_DEBUG("glBlendFunciEXT() -- done");
    } else {
        GAPID_INFO("glBlendFunciEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFunciEXT, s->GlesSpy::imports().glBlendFunciEXT);
        s->GlesSpy::imports().glBlendFunciEXT(buf, src, dst);
        GAPID_DEBUG("glBlendFunciEXT() -- done");
    }
}
EXPORT void STDCALL glColorMaskiEXT(DrawBufferIndex index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColorMaskiEXT(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", index, r, g, b, a);
    if (s->enter("glColorMaskiEXT")) {
        s->glColorMaskiEXT(index, r, g, b, a);
        s->exit();
        GAPID_DEBUG("glColorMaskiEXT() -- done");
    } else {
        GAPID_INFO("glColorMaskiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glColorMaskiEXT, s->GlesSpy::imports().glColorMaskiEXT);
        s->GlesSpy::imports().glColorMaskiEXT(index, r, g, b, a);
        GAPID_DEBUG("glColorMaskiEXT() -- done");
    }
}
EXPORT void STDCALL glCopyImageSubDataEXT(GLuint srcName, uint32_t srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, uint32_t dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyImageSubDataEXT(%" PRIu32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
    if (s->enter("glCopyImageSubDataEXT")) {
        s->glCopyImageSubDataEXT(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        s->exit();
        GAPID_DEBUG("glCopyImageSubDataEXT() -- done");
    } else {
        GAPID_INFO("glCopyImageSubDataEXT at %p: GAPII re-entered. Just invoking imported function at %p", glCopyImageSubDataEXT, s->GlesSpy::imports().glCopyImageSubDataEXT);
        s->GlesSpy::imports().glCopyImageSubDataEXT(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        GAPID_DEBUG("glCopyImageSubDataEXT() -- done");
    }
}
EXPORT void STDCALL glDebugMessageCallbackKHR(GLDEBUGPROC callback, void* userParam) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageCallbackKHR(%p, %p)", callback, userParam);
    if (s->enter("glDebugMessageCallbackKHR")) {
        s->glDebugMessageCallbackKHR(callback, userParam);
        s->exit();
        GAPID_DEBUG("glDebugMessageCallbackKHR() -- done");
    } else {
        GAPID_INFO("glDebugMessageCallbackKHR at %p: GAPII re-entered. Just invoking imported function at %p", glDebugMessageCallbackKHR, s->GlesSpy::imports().glDebugMessageCallbackKHR);
        s->GlesSpy::imports().glDebugMessageCallbackKHR(callback, userParam);
        GAPID_DEBUG("glDebugMessageCallbackKHR() -- done");
    }
}
EXPORT void STDCALL glDebugMessageControlKHR(uint32_t source, uint32_t type, uint32_t severity, GLsizei count, GLuint* ids, GLboolean enabled) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageControlKHR(%u, %u, %u, %" PRId32 ", %p, %" PRIu8 ")", source, type, severity, count, ids, enabled);
    if (s->enter("glDebugMessageControlKHR")) {
        s->glDebugMessageControlKHR(source, type, severity, count, ids, enabled);
        s->exit();
        GAPID_DEBUG("glDebugMessageControlKHR() -- done");
    } else {
        GAPID_INFO("glDebugMessageControlKHR at %p: GAPII re-entered. Just invoking imported function at %p", glDebugMessageControlKHR, s->GlesSpy::imports().glDebugMessageControlKHR);
        s->GlesSpy::imports().glDebugMessageControlKHR(source, type, severity, count, ids, enabled);
        GAPID_DEBUG("glDebugMessageControlKHR() -- done");
    }
}
EXPORT void STDCALL glDebugMessageInsertKHR(uint32_t source, uint32_t type, GLuint id, uint32_t severity, GLsizei length, GLchar* message) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageInsertKHR(%u, %u, %" PRIu32 ", %u, %" PRId32 ", %p)", source, type, id, severity, length, message);
    if (s->enter("glDebugMessageInsertKHR")) {
        s->glDebugMessageInsertKHR(source, type, id, severity, length, message);
        s->exit();
        GAPID_DEBUG("glDebugMessageInsertKHR() -- done");
    } else {
        GAPID_INFO("glDebugMessageInsertKHR at %p: GAPII re-entered. Just invoking imported function at %p", glDebugMessageInsertKHR, s->GlesSpy::imports().glDebugMessageInsertKHR);
        s->GlesSpy::imports().glDebugMessageInsertKHR(source, type, id, severity, length, message);
        GAPID_DEBUG("glDebugMessageInsertKHR() -- done");
    }
}
EXPORT void STDCALL glDisableiEXT(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableiEXT(%u, %" PRIu32 ")", target, index);
    if (s->enter("glDisableiEXT")) {
        s->glDisableiEXT(target, index);
        s->exit();
        GAPID_DEBUG("glDisableiEXT() -- done");
    } else {
        GAPID_INFO("glDisableiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDisableiEXT, s->GlesSpy::imports().glDisableiEXT);
        s->GlesSpy::imports().glDisableiEXT(target, index);
        GAPID_DEBUG("glDisableiEXT() -- done");
    }
}
EXPORT void STDCALL glEnableiEXT(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableiEXT(%u, %" PRIu32 ")", target, index);
    if (s->enter("glEnableiEXT")) {
        s->glEnableiEXT(target, index);
        s->exit();
        GAPID_DEBUG("glEnableiEXT() -- done");
    } else {
        GAPID_INFO("glEnableiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glEnableiEXT, s->GlesSpy::imports().glEnableiEXT);
        s->GlesSpy::imports().glEnableiEXT(target, index);
        GAPID_DEBUG("glEnableiEXT() -- done");
    }
}
EXPORT void STDCALL glFramebufferTextureEXT(uint32_t target, uint32_t attachment, TextureId texture, GLint level) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTextureEXT(%u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, texture, level);
    if (s->enter("glFramebufferTextureEXT")) {
        s->glFramebufferTextureEXT(target, attachment, texture, level);
        s->exit();
        GAPID_DEBUG("glFramebufferTextureEXT() -- done");
    } else {
        GAPID_INFO("glFramebufferTextureEXT at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTextureEXT, s->GlesSpy::imports().glFramebufferTextureEXT);
        s->GlesSpy::imports().glFramebufferTextureEXT(target, attachment, texture, level);
        GAPID_DEBUG("glFramebufferTextureEXT() -- done");
    }
}
EXPORT GLuint STDCALL glGetDebugMessageLogKHR(GLuint count, GLsizei bufSize, uint32_t* sources, uint32_t* types, GLuint* ids, uint32_t* severities, GLsizei* lengths, GLchar* messageLog) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetDebugMessageLogKHR(%" PRIu32 ", %" PRId32 ", %p, %p, %p, %p, %p, %p)", count, bufSize, sources, types, ids, severities, lengths, messageLog);
    if (s->enter("glGetDebugMessageLogKHR")) {
        auto _result_ = s->glGetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths, messageLog);
        s->exit();
        GAPID_DEBUG("glGetDebugMessageLogKHR() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetDebugMessageLogKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetDebugMessageLogKHR, s->GlesSpy::imports().glGetDebugMessageLogKHR);
        auto _result_ = s->GlesSpy::imports().glGetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths, messageLog);
        GAPID_DEBUG("glGetDebugMessageLogKHR() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetObjectLabelKHR(uint32_t identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetObjectLabelKHR(%u, %" PRIu32 ", %" PRId32 ", %p, %p)", identifier, name, bufSize, length, label);
    if (s->enter("glGetObjectLabelKHR")) {
        s->glGetObjectLabelKHR(identifier, name, bufSize, length, label);
        s->exit();
        GAPID_DEBUG("glGetObjectLabelKHR() -- done");
    } else {
        GAPID_INFO("glGetObjectLabelKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetObjectLabelKHR, s->GlesSpy::imports().glGetObjectLabelKHR);
        s->GlesSpy::imports().glGetObjectLabelKHR(identifier, name, bufSize, length, label);
        GAPID_DEBUG("glGetObjectLabelKHR() -- done");
    }
}
EXPORT void STDCALL glGetObjectPtrLabelKHR(void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetObjectPtrLabelKHR(%p, %" PRId32 ", %p, %p)", ptr, bufSize, length, label);
    if (s->enter("glGetObjectPtrLabelKHR")) {
        s->glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
        s->exit();
        GAPID_DEBUG("glGetObjectPtrLabelKHR() -- done");
    } else {
        GAPID_INFO("glGetObjectPtrLabelKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetObjectPtrLabelKHR, s->GlesSpy::imports().glGetObjectPtrLabelKHR);
        s->GlesSpy::imports().glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
        GAPID_DEBUG("glGetObjectPtrLabelKHR() -- done");
    }
}
EXPORT void STDCALL glGetPointervKHR(uint32_t pname, void** params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPointervKHR(%u, %p)", pname, params);
    if (s->enter("glGetPointervKHR")) {
        s->glGetPointervKHR(pname, params);
        s->exit();
        GAPID_DEBUG("glGetPointervKHR() -- done");
    } else {
        GAPID_INFO("glGetPointervKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetPointervKHR, s->GlesSpy::imports().glGetPointervKHR);
        s->GlesSpy::imports().glGetPointervKHR(pname, params);
        GAPID_DEBUG("glGetPointervKHR() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterIivEXT(SamplerId sampler, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterIivEXT(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterIivEXT")) {
        s->glGetSamplerParameterIivEXT(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterIivEXT() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterIivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterIivEXT, s->GlesSpy::imports().glGetSamplerParameterIivEXT);
        s->GlesSpy::imports().glGetSamplerParameterIivEXT(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterIivEXT() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterIuivEXT(SamplerId sampler, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterIuivEXT(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterIuivEXT")) {
        s->glGetSamplerParameterIuivEXT(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterIuivEXT() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterIuivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterIuivEXT, s->GlesSpy::imports().glGetSamplerParameterIuivEXT);
        s->GlesSpy::imports().glGetSamplerParameterIuivEXT(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterIuivEXT() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterIivEXT(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterIivEXT(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterIivEXT")) {
        s->glGetTexParameterIivEXT(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterIivEXT() -- done");
    } else {
        GAPID_INFO("glGetTexParameterIivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterIivEXT, s->GlesSpy::imports().glGetTexParameterIivEXT);
        s->GlesSpy::imports().glGetTexParameterIivEXT(target, pname, params);
        GAPID_DEBUG("glGetTexParameterIivEXT() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterIuivEXT(uint32_t target, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterIuivEXT(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterIuivEXT")) {
        s->glGetTexParameterIuivEXT(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterIuivEXT() -- done");
    } else {
        GAPID_INFO("glGetTexParameterIuivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterIuivEXT, s->GlesSpy::imports().glGetTexParameterIuivEXT);
        s->GlesSpy::imports().glGetTexParameterIuivEXT(target, pname, params);
        GAPID_DEBUG("glGetTexParameterIuivEXT() -- done");
    }
}
EXPORT GLboolean STDCALL glIsEnablediEXT(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsEnablediEXT(%u, %" PRIu32 ")", target, index);
    if (s->enter("glIsEnablediEXT")) {
        auto _result_ = s->glIsEnablediEXT(target, index);
        s->exit();
        GAPID_DEBUG("glIsEnablediEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsEnablediEXT at %p: GAPII re-entered. Just invoking imported function at %p", glIsEnablediEXT, s->GlesSpy::imports().glIsEnablediEXT);
        auto _result_ = s->GlesSpy::imports().glIsEnablediEXT(target, index);
        GAPID_DEBUG("glIsEnablediEXT() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glMinSampleShadingOES(GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMinSampleShadingOES(%f)", value);
    if (s->enter("glMinSampleShadingOES")) {
        s->glMinSampleShadingOES(value);
        s->exit();
        GAPID_DEBUG("glMinSampleShadingOES() -- done");
    } else {
        GAPID_INFO("glMinSampleShadingOES at %p: GAPII re-entered. Just invoking imported function at %p", glMinSampleShadingOES, s->GlesSpy::imports().glMinSampleShadingOES);
        s->GlesSpy::imports().glMinSampleShadingOES(value);
        GAPID_DEBUG("glMinSampleShadingOES() -- done");
    }
}
EXPORT void STDCALL glObjectLabelKHR(uint32_t identifier, GLuint name, GLsizei length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glObjectLabelKHR(%u, %" PRIu32 ", %" PRId32 ", %p)", identifier, name, length, label);
    if (s->enter("glObjectLabelKHR")) {
        s->glObjectLabelKHR(identifier, name, length, label);
        s->exit();
        GAPID_DEBUG("glObjectLabelKHR() -- done");
    } else {
        GAPID_INFO("glObjectLabelKHR at %p: GAPII re-entered. Just invoking imported function at %p", glObjectLabelKHR, s->GlesSpy::imports().glObjectLabelKHR);
        s->GlesSpy::imports().glObjectLabelKHR(identifier, name, length, label);
        GAPID_DEBUG("glObjectLabelKHR() -- done");
    }
}
EXPORT void STDCALL glObjectPtrLabelKHR(void* ptr, GLsizei length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glObjectPtrLabelKHR(%p, %" PRId32 ", %p)", ptr, length, label);
    if (s->enter("glObjectPtrLabelKHR")) {
        s->glObjectPtrLabelKHR(ptr, length, label);
        s->exit();
        GAPID_DEBUG("glObjectPtrLabelKHR() -- done");
    } else {
        GAPID_INFO("glObjectPtrLabelKHR at %p: GAPII re-entered. Just invoking imported function at %p", glObjectPtrLabelKHR, s->GlesSpy::imports().glObjectPtrLabelKHR);
        s->GlesSpy::imports().glObjectPtrLabelKHR(ptr, length, label);
        GAPID_DEBUG("glObjectPtrLabelKHR() -- done");
    }
}
EXPORT void STDCALL glPatchParameteriEXT(uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPatchParameteriEXT(%u, %" PRId32 ")", pname, value);
    if (s->enter("glPatchParameteriEXT")) {
        s->glPatchParameteriEXT(pname, value);
        s->exit();
        GAPID_DEBUG("glPatchParameteriEXT() -- done");
    } else {
        GAPID_INFO("glPatchParameteriEXT at %p: GAPII re-entered. Just invoking imported function at %p", glPatchParameteriEXT, s->GlesSpy::imports().glPatchParameteriEXT);
        s->GlesSpy::imports().glPatchParameteriEXT(pname, value);
        GAPID_DEBUG("glPatchParameteriEXT() -- done");
    }
}
EXPORT void STDCALL glPopDebugGroupKHR() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopDebugGroupKHR()");
    if (s->enter("glPopDebugGroupKHR")) {
        s->glPopDebugGroupKHR();
        s->exit();
        GAPID_DEBUG("glPopDebugGroupKHR() -- done");
    } else {
        GAPID_INFO("glPopDebugGroupKHR at %p: GAPII re-entered. Just invoking imported function at %p", glPopDebugGroupKHR, s->GlesSpy::imports().glPopDebugGroupKHR);
        s->GlesSpy::imports().glPopDebugGroupKHR();
        GAPID_DEBUG("glPopDebugGroupKHR() -- done");
    }
}
EXPORT void STDCALL glPrimitiveBoundingBoxEXT(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPrimitiveBoundingBoxEXT(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
    if (s->enter("glPrimitiveBoundingBoxEXT")) {
        s->glPrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
        s->exit();
        GAPID_DEBUG("glPrimitiveBoundingBoxEXT() -- done");
    } else {
        GAPID_INFO("glPrimitiveBoundingBoxEXT at %p: GAPII re-entered. Just invoking imported function at %p", glPrimitiveBoundingBoxEXT, s->GlesSpy::imports().glPrimitiveBoundingBoxEXT);
        s->GlesSpy::imports().glPrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
        GAPID_DEBUG("glPrimitiveBoundingBoxEXT() -- done");
    }
}
EXPORT void STDCALL glPushDebugGroupKHR(uint32_t source, GLuint id, GLsizei length, GLchar* message) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPushDebugGroupKHR(%u, %" PRIu32 ", %" PRId32 ", %p)", source, id, length, message);
    if (s->enter("glPushDebugGroupKHR")) {
        s->glPushDebugGroupKHR(source, id, length, message);
        s->exit();
        GAPID_DEBUG("glPushDebugGroupKHR() -- done");
    } else {
        GAPID_INFO("glPushDebugGroupKHR at %p: GAPII re-entered. Just invoking imported function at %p", glPushDebugGroupKHR, s->GlesSpy::imports().glPushDebugGroupKHR);
        s->GlesSpy::imports().glPushDebugGroupKHR(source, id, length, message);
        GAPID_DEBUG("glPushDebugGroupKHR() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterIivEXT(SamplerId sampler, uint32_t pname, GLint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterIivEXT(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterIivEXT")) {
        s->glSamplerParameterIivEXT(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterIivEXT() -- done");
    } else {
        GAPID_INFO("glSamplerParameterIivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterIivEXT, s->GlesSpy::imports().glSamplerParameterIivEXT);
        s->GlesSpy::imports().glSamplerParameterIivEXT(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterIivEXT() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterIuivEXT(SamplerId sampler, uint32_t pname, GLuint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterIuivEXT(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterIuivEXT")) {
        s->glSamplerParameterIuivEXT(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterIuivEXT() -- done");
    } else {
        GAPID_INFO("glSamplerParameterIuivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterIuivEXT, s->GlesSpy::imports().glSamplerParameterIuivEXT);
        s->GlesSpy::imports().glSamplerParameterIuivEXT(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterIuivEXT() -- done");
    }
}
EXPORT void STDCALL glTexBufferEXT(uint32_t target, uint32_t internalformat, BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexBufferEXT(%u, %u, %" PRIu32 ")", target, internalformat, buffer);
    if (s->enter("glTexBufferEXT")) {
        s->glTexBufferEXT(target, internalformat, buffer);
        s->exit();
        GAPID_DEBUG("glTexBufferEXT() -- done");
    } else {
        GAPID_INFO("glTexBufferEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexBufferEXT, s->GlesSpy::imports().glTexBufferEXT);
        s->GlesSpy::imports().glTexBufferEXT(target, internalformat, buffer);
        GAPID_DEBUG("glTexBufferEXT() -- done");
    }
}
EXPORT void STDCALL glTexBufferRangeEXT(uint32_t target, uint32_t internalformat, BufferId buffer, GLintptr offset, GLsizeiptr size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexBufferRangeEXT(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, internalformat, buffer, offset, size);
    if (s->enter("glTexBufferRangeEXT")) {
        s->glTexBufferRangeEXT(target, internalformat, buffer, offset, size);
        s->exit();
        GAPID_DEBUG("glTexBufferRangeEXT() -- done");
    } else {
        GAPID_INFO("glTexBufferRangeEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexBufferRangeEXT, s->GlesSpy::imports().glTexBufferRangeEXT);
        s->GlesSpy::imports().glTexBufferRangeEXT(target, internalformat, buffer, offset, size);
        GAPID_DEBUG("glTexBufferRangeEXT() -- done");
    }
}
EXPORT void STDCALL glTexParameterIivEXT(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterIivEXT(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterIivEXT")) {
        s->glTexParameterIivEXT(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterIivEXT() -- done");
    } else {
        GAPID_INFO("glTexParameterIivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterIivEXT, s->GlesSpy::imports().glTexParameterIivEXT);
        s->GlesSpy::imports().glTexParameterIivEXT(target, pname, params);
        GAPID_DEBUG("glTexParameterIivEXT() -- done");
    }
}
EXPORT void STDCALL glTexParameterIuivEXT(uint32_t target, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterIuivEXT(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterIuivEXT")) {
        s->glTexParameterIuivEXT(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterIuivEXT() -- done");
    } else {
        GAPID_INFO("glTexParameterIuivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterIuivEXT, s->GlesSpy::imports().glTexParameterIuivEXT);
        s->GlesSpy::imports().glTexParameterIuivEXT(target, pname, params);
        GAPID_DEBUG("glTexParameterIuivEXT() -- done");
    }
}
EXPORT void STDCALL glTexStorage3DMultisampleOES(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage3DMultisampleOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, samples, internalformat, width, height, depth, fixedsamplelocations);
    if (s->enter("glTexStorage3DMultisampleOES")) {
        s->glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, fixedsamplelocations);
        s->exit();
        GAPID_DEBUG("glTexStorage3DMultisampleOES() -- done");
    } else {
        GAPID_INFO("glTexStorage3DMultisampleOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage3DMultisampleOES, s->GlesSpy::imports().glTexStorage3DMultisampleOES);
        s->GlesSpy::imports().glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, fixedsamplelocations);
        GAPID_DEBUG("glTexStorage3DMultisampleOES() -- done");
    }
}
EXPORT void STDCALL glBeginQuery(uint32_t target, QueryId query) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginQuery(%u, %" PRIu32 ")", target, query);
    if (s->enter("glBeginQuery")) {
        s->glBeginQuery(target, query);
        s->exit();
        GAPID_DEBUG("glBeginQuery() -- done");
    } else {
        GAPID_INFO("glBeginQuery at %p: GAPII re-entered. Just invoking imported function at %p", glBeginQuery, s->GlesSpy::imports().glBeginQuery);
        s->GlesSpy::imports().glBeginQuery(target, query);
        GAPID_DEBUG("glBeginQuery() -- done");
    }
}
EXPORT void STDCALL glDeleteQueries(GLsizei count, QueryId* queries) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteQueries(%" PRId32 ", %p)", count, queries);
    if (s->enter("glDeleteQueries")) {
        s->glDeleteQueries(count, queries);
        s->exit();
        GAPID_DEBUG("glDeleteQueries() -- done");
    } else {
        GAPID_INFO("glDeleteQueries at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteQueries, s->GlesSpy::imports().glDeleteQueries);
        s->GlesSpy::imports().glDeleteQueries(count, queries);
        GAPID_DEBUG("glDeleteQueries() -- done");
    }
}
EXPORT void STDCALL glEndQuery(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndQuery(%u)", target);
    if (s->enter("glEndQuery")) {
        s->glEndQuery(target);
        s->exit();
        GAPID_DEBUG("glEndQuery() -- done");
    } else {
        GAPID_INFO("glEndQuery at %p: GAPII re-entered. Just invoking imported function at %p", glEndQuery, s->GlesSpy::imports().glEndQuery);
        s->GlesSpy::imports().glEndQuery(target);
        GAPID_DEBUG("glEndQuery() -- done");
    }
}
EXPORT void STDCALL glGenQueries(GLsizei count, QueryId* queries) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenQueries(%" PRId32 ", %p)", count, queries);
    if (s->enter("glGenQueries")) {
        s->glGenQueries(count, queries);
        s->exit();
        GAPID_DEBUG("glGenQueries() -- done");
    } else {
        GAPID_INFO("glGenQueries at %p: GAPII re-entered. Just invoking imported function at %p", glGenQueries, s->GlesSpy::imports().glGenQueries);
        s->GlesSpy::imports().glGenQueries(count, queries);
        GAPID_DEBUG("glGenQueries() -- done");
    }
}
EXPORT void STDCALL glGetQueryObjectuiv(QueryId query, uint32_t parameter, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjectuiv(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjectuiv")) {
        s->glGetQueryObjectuiv(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjectuiv() -- done");
    } else {
        GAPID_INFO("glGetQueryObjectuiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjectuiv, s->GlesSpy::imports().glGetQueryObjectuiv);
        s->GlesSpy::imports().glGetQueryObjectuiv(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjectuiv() -- done");
    }
}
EXPORT void STDCALL glGetQueryiv(uint32_t target, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryiv(%u, %u, %p)", target, parameter, value);
    if (s->enter("glGetQueryiv")) {
        s->glGetQueryiv(target, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryiv() -- done");
    } else {
        GAPID_INFO("glGetQueryiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryiv, s->GlesSpy::imports().glGetQueryiv);
        s->GlesSpy::imports().glGetQueryiv(target, parameter, value);
        GAPID_DEBUG("glGetQueryiv() -- done");
    }
}
EXPORT GLboolean STDCALL glIsQuery(QueryId query) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsQuery(%" PRIu32 ")", query);
    if (s->enter("glIsQuery")) {
        auto _result_ = s->glIsQuery(query);
        s->exit();
        GAPID_DEBUG("glIsQuery() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsQuery at %p: GAPII re-entered. Just invoking imported function at %p", glIsQuery, s->GlesSpy::imports().glIsQuery);
        auto _result_ = s->GlesSpy::imports().glIsQuery(query);
        GAPID_DEBUG("glIsQuery() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glBindBuffer(uint32_t target, BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindBuffer(%u, %" PRIu32 ")", target, buffer);
    if (s->enter("glBindBuffer")) {
        s->glBindBuffer(target, buffer);
        s->exit();
        GAPID_DEBUG("glBindBuffer() -- done");
    } else {
        GAPID_INFO("glBindBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glBindBuffer, s->GlesSpy::imports().glBindBuffer);
        s->GlesSpy::imports().glBindBuffer(target, buffer);
        GAPID_DEBUG("glBindBuffer() -- done");
    }
}
EXPORT void STDCALL glBindBufferBase(uint32_t target, GLuint index, BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindBufferBase(%u, %" PRIu32 ", %" PRIu32 ")", target, index, buffer);
    if (s->enter("glBindBufferBase")) {
        s->glBindBufferBase(target, index, buffer);
        s->exit();
        GAPID_DEBUG("glBindBufferBase() -- done");
    } else {
        GAPID_INFO("glBindBufferBase at %p: GAPII re-entered. Just invoking imported function at %p", glBindBufferBase, s->GlesSpy::imports().glBindBufferBase);
        s->GlesSpy::imports().glBindBufferBase(target, index, buffer);
        GAPID_DEBUG("glBindBufferBase() -- done");
    }
}
EXPORT void STDCALL glBindBufferRange(uint32_t target, GLuint index, BufferId buffer, GLintptr offset, GLsizeiptr size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindBufferRange(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, index, buffer, offset, size);
    if (s->enter("glBindBufferRange")) {
        s->glBindBufferRange(target, index, buffer, offset, size);
        s->exit();
        GAPID_DEBUG("glBindBufferRange() -- done");
    } else {
        GAPID_INFO("glBindBufferRange at %p: GAPII re-entered. Just invoking imported function at %p", glBindBufferRange, s->GlesSpy::imports().glBindBufferRange);
        s->GlesSpy::imports().glBindBufferRange(target, index, buffer, offset, size);
        GAPID_DEBUG("glBindBufferRange() -- done");
    }
}
EXPORT void STDCALL glBufferData(uint32_t target, GLsizeiptr size, BufferDataPointer data, uint32_t usage) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBufferData(%u, %" PRId32 ", %p, %u)", target, size, data, usage);
    if (s->enter("glBufferData")) {
        s->glBufferData(target, size, data, usage);
        s->exit();
        GAPID_DEBUG("glBufferData() -- done");
    } else {
        GAPID_INFO("glBufferData at %p: GAPII re-entered. Just invoking imported function at %p", glBufferData, s->GlesSpy::imports().glBufferData);
        s->GlesSpy::imports().glBufferData(target, size, data, usage);
        GAPID_DEBUG("glBufferData() -- done");
    }
}
EXPORT void STDCALL glBufferSubData(uint32_t target, GLintptr offset, GLsizeiptr size, BufferDataPointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBufferSubData(%u, %" PRId32 ", %" PRId32 ", %p)", target, offset, size, data);
    if (s->enter("glBufferSubData")) {
        s->glBufferSubData(target, offset, size, data);
        s->exit();
        GAPID_DEBUG("glBufferSubData() -- done");
    } else {
        GAPID_INFO("glBufferSubData at %p: GAPII re-entered. Just invoking imported function at %p", glBufferSubData, s->GlesSpy::imports().glBufferSubData);
        s->GlesSpy::imports().glBufferSubData(target, offset, size, data);
        GAPID_DEBUG("glBufferSubData() -- done");
    }
}
EXPORT void STDCALL glCopyBufferSubData(uint32_t readTarget, uint32_t writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyBufferSubData(%u, %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", readTarget, writeTarget, readOffset, writeOffset, size);
    if (s->enter("glCopyBufferSubData")) {
        s->glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
        s->exit();
        GAPID_DEBUG("glCopyBufferSubData() -- done");
    } else {
        GAPID_INFO("glCopyBufferSubData at %p: GAPII re-entered. Just invoking imported function at %p", glCopyBufferSubData, s->GlesSpy::imports().glCopyBufferSubData);
        s->GlesSpy::imports().glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
        GAPID_DEBUG("glCopyBufferSubData() -- done");
    }
}
EXPORT void STDCALL glDeleteBuffers(GLsizei count, BufferId* buffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteBuffers(%" PRId32 ", %p)", count, buffers);
    if (s->enter("glDeleteBuffers")) {
        s->glDeleteBuffers(count, buffers);
        s->exit();
        GAPID_DEBUG("glDeleteBuffers() -- done");
    } else {
        GAPID_INFO("glDeleteBuffers at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteBuffers, s->GlesSpy::imports().glDeleteBuffers);
        s->GlesSpy::imports().glDeleteBuffers(count, buffers);
        GAPID_DEBUG("glDeleteBuffers() -- done");
    }
}
EXPORT void STDCALL glGenBuffers(GLsizei count, BufferId* buffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenBuffers(%" PRId32 ", %p)", count, buffers);
    if (s->enter("glGenBuffers")) {
        s->glGenBuffers(count, buffers);
        s->exit();
        GAPID_DEBUG("glGenBuffers() -- done");
    } else {
        GAPID_INFO("glGenBuffers at %p: GAPII re-entered. Just invoking imported function at %p", glGenBuffers, s->GlesSpy::imports().glGenBuffers);
        s->GlesSpy::imports().glGenBuffers(count, buffers);
        GAPID_DEBUG("glGenBuffers() -- done");
    }
}
EXPORT void STDCALL glGetBufferParameteri64v(uint32_t target, uint32_t parameter, GLint64* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetBufferParameteri64v(%u, %u, %p)", target, parameter, value);
    if (s->enter("glGetBufferParameteri64v")) {
        s->glGetBufferParameteri64v(target, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetBufferParameteri64v() -- done");
    } else {
        GAPID_INFO("glGetBufferParameteri64v at %p: GAPII re-entered. Just invoking imported function at %p", glGetBufferParameteri64v, s->GlesSpy::imports().glGetBufferParameteri64v);
        s->GlesSpy::imports().glGetBufferParameteri64v(target, parameter, value);
        GAPID_DEBUG("glGetBufferParameteri64v() -- done");
    }
}
EXPORT void STDCALL glGetBufferParameteriv(uint32_t target, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetBufferParameteriv(%u, %u, %p)", target, parameter, value);
    if (s->enter("glGetBufferParameteriv")) {
        s->glGetBufferParameteriv(target, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetBufferParameteriv() -- done");
    } else {
        GAPID_INFO("glGetBufferParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetBufferParameteriv, s->GlesSpy::imports().glGetBufferParameteriv);
        s->GlesSpy::imports().glGetBufferParameteriv(target, parameter, value);
        GAPID_DEBUG("glGetBufferParameteriv() -- done");
    }
}
EXPORT void STDCALL glGetBufferPointerv(uint32_t target, uint32_t pname, void** params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetBufferPointerv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetBufferPointerv")) {
        s->glGetBufferPointerv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetBufferPointerv() -- done");
    } else {
        GAPID_INFO("glGetBufferPointerv at %p: GAPII re-entered. Just invoking imported function at %p", glGetBufferPointerv, s->GlesSpy::imports().glGetBufferPointerv);
        s->GlesSpy::imports().glGetBufferPointerv(target, pname, params);
        GAPID_DEBUG("glGetBufferPointerv() -- done");
    }
}
EXPORT GLboolean STDCALL glIsBuffer(BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsBuffer(%" PRIu32 ")", buffer);
    if (s->enter("glIsBuffer")) {
        auto _result_ = s->glIsBuffer(buffer);
        s->exit();
        GAPID_DEBUG("glIsBuffer() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glIsBuffer, s->GlesSpy::imports().glIsBuffer);
        auto _result_ = s->GlesSpy::imports().glIsBuffer(buffer);
        GAPID_DEBUG("glIsBuffer() -- done");
        return _result_;
    }
}
EXPORT void* STDCALL glMapBufferRange(uint32_t target, GLintptr offset, GLsizeiptr length, uint32_t access) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMapBufferRange(%u, %" PRId32 ", %" PRId32 ", %u)", target, offset, length, access);
    if (s->enter("glMapBufferRange")) {
        auto _result_ = s->glMapBufferRange(target, offset, length, access);
        s->exit();
        GAPID_DEBUG("glMapBufferRange() -- done");
        return _result_;
    } else {
        GAPID_INFO("glMapBufferRange at %p: GAPII re-entered. Just invoking imported function at %p", glMapBufferRange, s->GlesSpy::imports().glMapBufferRange);
        auto _result_ = s->GlesSpy::imports().glMapBufferRange(target, offset, length, access);
        GAPID_DEBUG("glMapBufferRange() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glUnmapBuffer(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUnmapBuffer(%u)", target);
    if (s->enter("glUnmapBuffer")) {
        auto _result_ = s->glUnmapBuffer(target);
        s->exit();
        GAPID_DEBUG("glUnmapBuffer() -- done");
        return _result_;
    } else {
        GAPID_INFO("glUnmapBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glUnmapBuffer, s->GlesSpy::imports().glUnmapBuffer);
        auto _result_ = s->GlesSpy::imports().glUnmapBuffer(target);
        GAPID_DEBUG("glUnmapBuffer() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glDebugMessageCallback(GLDEBUGPROC callback, void* userParam) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageCallback(%p, %p)", callback, userParam);
    if (s->enter("glDebugMessageCallback")) {
        s->glDebugMessageCallback(callback, userParam);
        s->exit();
        GAPID_DEBUG("glDebugMessageCallback() -- done");
    } else {
        GAPID_INFO("glDebugMessageCallback at %p: GAPII re-entered. Just invoking imported function at %p", glDebugMessageCallback, s->GlesSpy::imports().glDebugMessageCallback);
        s->GlesSpy::imports().glDebugMessageCallback(callback, userParam);
        GAPID_DEBUG("glDebugMessageCallback() -- done");
    }
}
EXPORT void STDCALL glDebugMessageControl(uint32_t source, uint32_t type, uint32_t severity, GLsizei count, GLuint* ids, GLboolean enabled) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageControl(%u, %u, %u, %" PRId32 ", %p, %" PRIu8 ")", source, type, severity, count, ids, enabled);
    if (s->enter("glDebugMessageControl")) {
        s->glDebugMessageControl(source, type, severity, count, ids, enabled);
        s->exit();
        GAPID_DEBUG("glDebugMessageControl() -- done");
    } else {
        GAPID_INFO("glDebugMessageControl at %p: GAPII re-entered. Just invoking imported function at %p", glDebugMessageControl, s->GlesSpy::imports().glDebugMessageControl);
        s->GlesSpy::imports().glDebugMessageControl(source, type, severity, count, ids, enabled);
        GAPID_DEBUG("glDebugMessageControl() -- done");
    }
}
EXPORT void STDCALL glDebugMessageInsert(uint32_t source, uint32_t type, GLuint id, uint32_t severity, GLsizei length, GLchar* message) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageInsert(%u, %u, %" PRIu32 ", %u, %" PRId32 ", %p)", source, type, id, severity, length, message);
    if (s->enter("glDebugMessageInsert")) {
        s->glDebugMessageInsert(source, type, id, severity, length, message);
        s->exit();
        GAPID_DEBUG("glDebugMessageInsert() -- done");
    } else {
        GAPID_INFO("glDebugMessageInsert at %p: GAPII re-entered. Just invoking imported function at %p", glDebugMessageInsert, s->GlesSpy::imports().glDebugMessageInsert);
        s->GlesSpy::imports().glDebugMessageInsert(source, type, id, severity, length, message);
        GAPID_DEBUG("glDebugMessageInsert() -- done");
    }
}
EXPORT GLuint STDCALL glGetDebugMessageLog(GLuint count, GLsizei bufSize, uint32_t* sources, uint32_t* types, GLuint* ids, uint32_t* severities, GLsizei* lengths, GLchar* messageLog) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetDebugMessageLog(%" PRIu32 ", %" PRId32 ", %p, %p, %p, %p, %p, %p)", count, bufSize, sources, types, ids, severities, lengths, messageLog);
    if (s->enter("glGetDebugMessageLog")) {
        auto _result_ = s->glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
        s->exit();
        GAPID_DEBUG("glGetDebugMessageLog() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetDebugMessageLog at %p: GAPII re-entered. Just invoking imported function at %p", glGetDebugMessageLog, s->GlesSpy::imports().glGetDebugMessageLog);
        auto _result_ = s->GlesSpy::imports().glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
        GAPID_DEBUG("glGetDebugMessageLog() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetObjectLabel(uint32_t identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetObjectLabel(%u, %" PRIu32 ", %" PRId32 ", %p, %p)", identifier, name, bufSize, length, label);
    if (s->enter("glGetObjectLabel")) {
        s->glGetObjectLabel(identifier, name, bufSize, length, label);
        s->exit();
        GAPID_DEBUG("glGetObjectLabel() -- done");
    } else {
        GAPID_INFO("glGetObjectLabel at %p: GAPII re-entered. Just invoking imported function at %p", glGetObjectLabel, s->GlesSpy::imports().glGetObjectLabel);
        s->GlesSpy::imports().glGetObjectLabel(identifier, name, bufSize, length, label);
        GAPID_DEBUG("glGetObjectLabel() -- done");
    }
}
EXPORT void STDCALL glGetObjectPtrLabel(void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetObjectPtrLabel(%p, %" PRId32 ", %p, %p)", ptr, bufSize, length, label);
    if (s->enter("glGetObjectPtrLabel")) {
        s->glGetObjectPtrLabel(ptr, bufSize, length, label);
        s->exit();
        GAPID_DEBUG("glGetObjectPtrLabel() -- done");
    } else {
        GAPID_INFO("glGetObjectPtrLabel at %p: GAPII re-entered. Just invoking imported function at %p", glGetObjectPtrLabel, s->GlesSpy::imports().glGetObjectPtrLabel);
        s->GlesSpy::imports().glGetObjectPtrLabel(ptr, bufSize, length, label);
        GAPID_DEBUG("glGetObjectPtrLabel() -- done");
    }
}
EXPORT void STDCALL glGetPointerv(uint32_t pname, void** params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPointerv(%u, %p)", pname, params);
    if (s->enter("glGetPointerv")) {
        s->glGetPointerv(pname, params);
        s->exit();
        GAPID_DEBUG("glGetPointerv() -- done");
    } else {
        GAPID_INFO("glGetPointerv at %p: GAPII re-entered. Just invoking imported function at %p", glGetPointerv, s->GlesSpy::imports().glGetPointerv);
        s->GlesSpy::imports().glGetPointerv(pname, params);
        GAPID_DEBUG("glGetPointerv() -- done");
    }
}
EXPORT void STDCALL glObjectLabel(uint32_t identifier, GLuint name, GLsizei length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glObjectLabel(%u, %" PRIu32 ", %" PRId32 ", %p)", identifier, name, length, label);
    if (s->enter("glObjectLabel")) {
        s->glObjectLabel(identifier, name, length, label);
        s->exit();
        GAPID_DEBUG("glObjectLabel() -- done");
    } else {
        GAPID_INFO("glObjectLabel at %p: GAPII re-entered. Just invoking imported function at %p", glObjectLabel, s->GlesSpy::imports().glObjectLabel);
        s->GlesSpy::imports().glObjectLabel(identifier, name, length, label);
        GAPID_DEBUG("glObjectLabel() -- done");
    }
}
EXPORT void STDCALL glObjectPtrLabel(void* ptr, GLsizei length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glObjectPtrLabel(%p, %" PRId32 ", %p)", ptr, length, label);
    if (s->enter("glObjectPtrLabel")) {
        s->glObjectPtrLabel(ptr, length, label);
        s->exit();
        GAPID_DEBUG("glObjectPtrLabel() -- done");
    } else {
        GAPID_INFO("glObjectPtrLabel at %p: GAPII re-entered. Just invoking imported function at %p", glObjectPtrLabel, s->GlesSpy::imports().glObjectPtrLabel);
        s->GlesSpy::imports().glObjectPtrLabel(ptr, length, label);
        GAPID_DEBUG("glObjectPtrLabel() -- done");
    }
}
EXPORT void STDCALL glPopDebugGroup() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopDebugGroup()");
    if (s->enter("glPopDebugGroup")) {
        s->glPopDebugGroup();
        s->exit();
        GAPID_DEBUG("glPopDebugGroup() -- done");
    } else {
        GAPID_INFO("glPopDebugGroup at %p: GAPII re-entered. Just invoking imported function at %p", glPopDebugGroup, s->GlesSpy::imports().glPopDebugGroup);
        s->GlesSpy::imports().glPopDebugGroup();
        GAPID_DEBUG("glPopDebugGroup() -- done");
    }
}
EXPORT void STDCALL glPushDebugGroup(uint32_t source, GLuint id, GLsizei length, GLchar* message) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPushDebugGroup(%u, %" PRIu32 ", %" PRId32 ", %p)", source, id, length, message);
    if (s->enter("glPushDebugGroup")) {
        s->glPushDebugGroup(source, id, length, message);
        s->exit();
        GAPID_DEBUG("glPushDebugGroup() -- done");
    } else {
        GAPID_INFO("glPushDebugGroup at %p: GAPII re-entered. Just invoking imported function at %p", glPushDebugGroup, s->GlesSpy::imports().glPushDebugGroup);
        s->GlesSpy::imports().glPushDebugGroup(source, id, length, message);
        GAPID_DEBUG("glPushDebugGroup() -- done");
    }
}
EXPORT void STDCALL glDrawArrays(uint32_t draw_mode, GLint first_index, GLsizei indices_count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArrays(%u, %" PRId32 ", %" PRId32 ")", draw_mode, first_index, indices_count);
    if (s->enter("glDrawArrays")) {
        s->glDrawArrays(draw_mode, first_index, indices_count);
        s->exit();
        GAPID_DEBUG("glDrawArrays() -- done");
    } else {
        GAPID_INFO("glDrawArrays at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArrays, s->GlesSpy::imports().glDrawArrays);
        s->GlesSpy::imports().glDrawArrays(draw_mode, first_index, indices_count);
        GAPID_DEBUG("glDrawArrays() -- done");
    }
}
EXPORT void STDCALL glDrawArraysIndirect(uint32_t draw_mode, void* indirect) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArraysIndirect(%u, %p)", draw_mode, indirect);
    if (s->enter("glDrawArraysIndirect")) {
        s->glDrawArraysIndirect(draw_mode, indirect);
        s->exit();
        GAPID_DEBUG("glDrawArraysIndirect() -- done");
    } else {
        GAPID_INFO("glDrawArraysIndirect at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArraysIndirect, s->GlesSpy::imports().glDrawArraysIndirect);
        s->GlesSpy::imports().glDrawArraysIndirect(draw_mode, indirect);
        GAPID_DEBUG("glDrawArraysIndirect() -- done");
    }
}
EXPORT void STDCALL glDrawArraysInstanced(uint32_t draw_mode, GLint first_index, GLsizei indices_count, GLsizei instance_count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArraysInstanced(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", draw_mode, first_index, indices_count, instance_count);
    if (s->enter("glDrawArraysInstanced")) {
        s->glDrawArraysInstanced(draw_mode, first_index, indices_count, instance_count);
        s->exit();
        GAPID_DEBUG("glDrawArraysInstanced() -- done");
    } else {
        GAPID_INFO("glDrawArraysInstanced at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArraysInstanced, s->GlesSpy::imports().glDrawArraysInstanced);
        s->GlesSpy::imports().glDrawArraysInstanced(draw_mode, first_index, indices_count, instance_count);
        GAPID_DEBUG("glDrawArraysInstanced() -- done");
    }
}
EXPORT void STDCALL glDrawElements(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElements(%u, %" PRId32 ", %u, %p)", draw_mode, indices_count, indices_type, indices);
    if (s->enter("glDrawElements")) {
        s->glDrawElements(draw_mode, indices_count, indices_type, indices);
        s->exit();
        GAPID_DEBUG("glDrawElements() -- done");
    } else {
        GAPID_INFO("glDrawElements at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElements, s->GlesSpy::imports().glDrawElements);
        s->GlesSpy::imports().glDrawElements(draw_mode, indices_count, indices_type, indices);
        GAPID_DEBUG("glDrawElements() -- done");
    }
}
EXPORT void STDCALL glDrawElementsBaseVertex(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLint base_vertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsBaseVertex(%u, %" PRId32 ", %u, %p, %" PRId32 ")", draw_mode, indices_count, indices_type, indices, base_vertex);
    if (s->enter("glDrawElementsBaseVertex")) {
        s->glDrawElementsBaseVertex(draw_mode, indices_count, indices_type, indices, base_vertex);
        s->exit();
        GAPID_DEBUG("glDrawElementsBaseVertex() -- done");
    } else {
        GAPID_INFO("glDrawElementsBaseVertex at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsBaseVertex, s->GlesSpy::imports().glDrawElementsBaseVertex);
        s->GlesSpy::imports().glDrawElementsBaseVertex(draw_mode, indices_count, indices_type, indices, base_vertex);
        GAPID_DEBUG("glDrawElementsBaseVertex() -- done");
    }
}
EXPORT void STDCALL glDrawElementsIndirect(uint32_t draw_mode, uint32_t indices_type, void* indirect) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsIndirect(%u, %u, %p)", draw_mode, indices_type, indirect);
    if (s->enter("glDrawElementsIndirect")) {
        s->glDrawElementsIndirect(draw_mode, indices_type, indirect);
        s->exit();
        GAPID_DEBUG("glDrawElementsIndirect() -- done");
    } else {
        GAPID_INFO("glDrawElementsIndirect at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsIndirect, s->GlesSpy::imports().glDrawElementsIndirect);
        s->GlesSpy::imports().glDrawElementsIndirect(draw_mode, indices_type, indirect);
        GAPID_DEBUG("glDrawElementsIndirect() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstanced(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLsizei instance_count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstanced(%u, %" PRId32 ", %u, %p, %" PRId32 ")", draw_mode, indices_count, indices_type, indices, instance_count);
    if (s->enter("glDrawElementsInstanced")) {
        s->glDrawElementsInstanced(draw_mode, indices_count, indices_type, indices, instance_count);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstanced() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstanced at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstanced, s->GlesSpy::imports().glDrawElementsInstanced);
        s->GlesSpy::imports().glDrawElementsInstanced(draw_mode, indices_count, indices_type, indices, instance_count);
        GAPID_DEBUG("glDrawElementsInstanced() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedBaseVertex(uint32_t draw_mode, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLsizei instance_count, GLint base_vertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedBaseVertex(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ")", draw_mode, indices_count, indices_type, indices, instance_count, base_vertex);
    if (s->enter("glDrawElementsInstancedBaseVertex")) {
        s->glDrawElementsInstancedBaseVertex(draw_mode, indices_count, indices_type, indices, instance_count, base_vertex);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedBaseVertex() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedBaseVertex at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedBaseVertex, s->GlesSpy::imports().glDrawElementsInstancedBaseVertex);
        s->GlesSpy::imports().glDrawElementsInstancedBaseVertex(draw_mode, indices_count, indices_type, indices, instance_count, base_vertex);
        GAPID_DEBUG("glDrawElementsInstancedBaseVertex() -- done");
    }
}
EXPORT void STDCALL glDrawRangeElements(uint32_t draw_mode, GLuint start, GLuint end, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawRangeElements(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p)", draw_mode, start, end, indices_count, indices_type, indices);
    if (s->enter("glDrawRangeElements")) {
        s->glDrawRangeElements(draw_mode, start, end, indices_count, indices_type, indices);
        s->exit();
        GAPID_DEBUG("glDrawRangeElements() -- done");
    } else {
        GAPID_INFO("glDrawRangeElements at %p: GAPII re-entered. Just invoking imported function at %p", glDrawRangeElements, s->GlesSpy::imports().glDrawRangeElements);
        s->GlesSpy::imports().glDrawRangeElements(draw_mode, start, end, indices_count, indices_type, indices);
        GAPID_DEBUG("glDrawRangeElements() -- done");
    }
}
EXPORT void STDCALL glDrawRangeElementsBaseVertex(uint32_t draw_mode, GLuint start, GLuint end, GLsizei indices_count, uint32_t indices_type, IndicesPointer indices, GLint base_vertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawRangeElementsBaseVertex(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p, %" PRId32 ")", draw_mode, start, end, indices_count, indices_type, indices, base_vertex);
    if (s->enter("glDrawRangeElementsBaseVertex")) {
        s->glDrawRangeElementsBaseVertex(draw_mode, start, end, indices_count, indices_type, indices, base_vertex);
        s->exit();
        GAPID_DEBUG("glDrawRangeElementsBaseVertex() -- done");
    } else {
        GAPID_INFO("glDrawRangeElementsBaseVertex at %p: GAPII re-entered. Just invoking imported function at %p", glDrawRangeElementsBaseVertex, s->GlesSpy::imports().glDrawRangeElementsBaseVertex);
        s->GlesSpy::imports().glDrawRangeElementsBaseVertex(draw_mode, start, end, indices_count, indices_type, indices, base_vertex);
        GAPID_DEBUG("glDrawRangeElementsBaseVertex() -- done");
    }
}
EXPORT void STDCALL glPatchParameteri(uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPatchParameteri(%u, %" PRId32 ")", pname, value);
    if (s->enter("glPatchParameteri")) {
        s->glPatchParameteri(pname, value);
        s->exit();
        GAPID_DEBUG("glPatchParameteri() -- done");
    } else {
        GAPID_INFO("glPatchParameteri at %p: GAPII re-entered. Just invoking imported function at %p", glPatchParameteri, s->GlesSpy::imports().glPatchParameteri);
        s->GlesSpy::imports().glPatchParameteri(pname, value);
        GAPID_DEBUG("glPatchParameteri() -- done");
    }
}
EXPORT void STDCALL glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPrimitiveBoundingBox(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
    if (s->enter("glPrimitiveBoundingBox")) {
        s->glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
        s->exit();
        GAPID_DEBUG("glPrimitiveBoundingBox() -- done");
    } else {
        GAPID_INFO("glPrimitiveBoundingBox at %p: GAPII re-entered. Just invoking imported function at %p", glPrimitiveBoundingBox, s->GlesSpy::imports().glPrimitiveBoundingBox);
        s->GlesSpy::imports().glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
        GAPID_DEBUG("glPrimitiveBoundingBox() -- done");
    }
}
EXPORT void STDCALL glActiveShaderProgramEXT(PipelineId pipeline, ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glActiveShaderProgramEXT(%" PRIu32 ", %" PRIu32 ")", pipeline, program);
    if (s->enter("glActiveShaderProgramEXT")) {
        s->glActiveShaderProgramEXT(pipeline, program);
        s->exit();
        GAPID_DEBUG("glActiveShaderProgramEXT() -- done");
    } else {
        GAPID_INFO("glActiveShaderProgramEXT at %p: GAPII re-entered. Just invoking imported function at %p", glActiveShaderProgramEXT, s->GlesSpy::imports().glActiveShaderProgramEXT);
        s->GlesSpy::imports().glActiveShaderProgramEXT(pipeline, program);
        GAPID_DEBUG("glActiveShaderProgramEXT() -- done");
    }
}
EXPORT void STDCALL glAlphaFuncQCOM(uint32_t func, GLclampf ref) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glAlphaFuncQCOM(%u, %f)", func, ref);
    if (s->enter("glAlphaFuncQCOM")) {
        s->glAlphaFuncQCOM(func, ref);
        s->exit();
        GAPID_DEBUG("glAlphaFuncQCOM() -- done");
    } else {
        GAPID_INFO("glAlphaFuncQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glAlphaFuncQCOM, s->GlesSpy::imports().glAlphaFuncQCOM);
        s->GlesSpy::imports().glAlphaFuncQCOM(func, ref);
        GAPID_DEBUG("glAlphaFuncQCOM() -- done");
    }
}
EXPORT void STDCALL glApplyFramebufferAttachmentCMAAINTEL() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glApplyFramebufferAttachmentCMAAINTEL()");
    if (s->enter("glApplyFramebufferAttachmentCMAAINTEL")) {
        s->glApplyFramebufferAttachmentCMAAINTEL();
        s->exit();
        GAPID_DEBUG("glApplyFramebufferAttachmentCMAAINTEL() -- done");
    } else {
        GAPID_INFO("glApplyFramebufferAttachmentCMAAINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glApplyFramebufferAttachmentCMAAINTEL, s->GlesSpy::imports().glApplyFramebufferAttachmentCMAAINTEL);
        s->GlesSpy::imports().glApplyFramebufferAttachmentCMAAINTEL();
        GAPID_DEBUG("glApplyFramebufferAttachmentCMAAINTEL() -- done");
    }
}
EXPORT void STDCALL glBeginConditionalRenderNV(GLuint id, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginConditionalRenderNV(%" PRIu32 ", %u)", id, mode);
    if (s->enter("glBeginConditionalRenderNV")) {
        s->glBeginConditionalRenderNV(id, mode);
        s->exit();
        GAPID_DEBUG("glBeginConditionalRenderNV() -- done");
    } else {
        GAPID_INFO("glBeginConditionalRenderNV at %p: GAPII re-entered. Just invoking imported function at %p", glBeginConditionalRenderNV, s->GlesSpy::imports().glBeginConditionalRenderNV);
        s->GlesSpy::imports().glBeginConditionalRenderNV(id, mode);
        GAPID_DEBUG("glBeginConditionalRenderNV() -- done");
    }
}
EXPORT void STDCALL glBeginPerfMonitorAMD(GLuint monitor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginPerfMonitorAMD(%" PRIu32 ")", monitor);
    if (s->enter("glBeginPerfMonitorAMD")) {
        s->glBeginPerfMonitorAMD(monitor);
        s->exit();
        GAPID_DEBUG("glBeginPerfMonitorAMD() -- done");
    } else {
        GAPID_INFO("glBeginPerfMonitorAMD at %p: GAPII re-entered. Just invoking imported function at %p", glBeginPerfMonitorAMD, s->GlesSpy::imports().glBeginPerfMonitorAMD);
        s->GlesSpy::imports().glBeginPerfMonitorAMD(monitor);
        GAPID_DEBUG("glBeginPerfMonitorAMD() -- done");
    }
}
EXPORT void STDCALL glBeginPerfQueryINTEL(GLuint queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginPerfQueryINTEL(%" PRIu32 ")", queryHandle);
    if (s->enter("glBeginPerfQueryINTEL")) {
        s->glBeginPerfQueryINTEL(queryHandle);
        s->exit();
        GAPID_DEBUG("glBeginPerfQueryINTEL() -- done");
    } else {
        GAPID_INFO("glBeginPerfQueryINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glBeginPerfQueryINTEL, s->GlesSpy::imports().glBeginPerfQueryINTEL);
        s->GlesSpy::imports().glBeginPerfQueryINTEL(queryHandle);
        GAPID_DEBUG("glBeginPerfQueryINTEL() -- done");
    }
}
EXPORT void STDCALL glBeginQueryEXT(uint32_t target, QueryId query) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginQueryEXT(%u, %" PRIu32 ")", target, query);
    if (s->enter("glBeginQueryEXT")) {
        s->glBeginQueryEXT(target, query);
        s->exit();
        GAPID_DEBUG("glBeginQueryEXT() -- done");
    } else {
        GAPID_INFO("glBeginQueryEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBeginQueryEXT, s->GlesSpy::imports().glBeginQueryEXT);
        s->GlesSpy::imports().glBeginQueryEXT(target, query);
        GAPID_DEBUG("glBeginQueryEXT() -- done");
    }
}
EXPORT void STDCALL glBindFragDataLocationEXT(ProgramId program, GLuint color, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindFragDataLocationEXT(%" PRIu32 ", %" PRIu32 ", %s)", program, color, name);
    if (s->enter("glBindFragDataLocationEXT")) {
        s->glBindFragDataLocationEXT(program, color, name);
        s->exit();
        GAPID_DEBUG("glBindFragDataLocationEXT() -- done");
    } else {
        GAPID_INFO("glBindFragDataLocationEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBindFragDataLocationEXT, s->GlesSpy::imports().glBindFragDataLocationEXT);
        s->GlesSpy::imports().glBindFragDataLocationEXT(program, color, name);
        GAPID_DEBUG("glBindFragDataLocationEXT() -- done");
    }
}
EXPORT void STDCALL glBindFragDataLocationIndexedEXT(ProgramId program, GLuint colorNumber, GLuint index, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindFragDataLocationIndexedEXT(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %s)", program, colorNumber, index, name);
    if (s->enter("glBindFragDataLocationIndexedEXT")) {
        s->glBindFragDataLocationIndexedEXT(program, colorNumber, index, name);
        s->exit();
        GAPID_DEBUG("glBindFragDataLocationIndexedEXT() -- done");
    } else {
        GAPID_INFO("glBindFragDataLocationIndexedEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBindFragDataLocationIndexedEXT, s->GlesSpy::imports().glBindFragDataLocationIndexedEXT);
        s->GlesSpy::imports().glBindFragDataLocationIndexedEXT(program, colorNumber, index, name);
        GAPID_DEBUG("glBindFragDataLocationIndexedEXT() -- done");
    }
}
EXPORT void STDCALL glBindProgramPipelineEXT(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindProgramPipelineEXT(%" PRIu32 ")", pipeline);
    if (s->enter("glBindProgramPipelineEXT")) {
        s->glBindProgramPipelineEXT(pipeline);
        s->exit();
        GAPID_DEBUG("glBindProgramPipelineEXT() -- done");
    } else {
        GAPID_INFO("glBindProgramPipelineEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBindProgramPipelineEXT, s->GlesSpy::imports().glBindProgramPipelineEXT);
        s->GlesSpy::imports().glBindProgramPipelineEXT(pipeline);
        GAPID_DEBUG("glBindProgramPipelineEXT() -- done");
    }
}
EXPORT void STDCALL glBindVertexArrayOES(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindVertexArrayOES(%" PRIu32 ")", array);
    if (s->enter("glBindVertexArrayOES")) {
        s->glBindVertexArrayOES(array);
        s->exit();
        GAPID_DEBUG("glBindVertexArrayOES() -- done");
    } else {
        GAPID_INFO("glBindVertexArrayOES at %p: GAPII re-entered. Just invoking imported function at %p", glBindVertexArrayOES, s->GlesSpy::imports().glBindVertexArrayOES);
        s->GlesSpy::imports().glBindVertexArrayOES(array);
        GAPID_DEBUG("glBindVertexArrayOES() -- done");
    }
}
EXPORT void STDCALL glBlendBarrierNV() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendBarrierNV()");
    if (s->enter("glBlendBarrierNV")) {
        s->glBlendBarrierNV();
        s->exit();
        GAPID_DEBUG("glBlendBarrierNV() -- done");
    } else {
        GAPID_INFO("glBlendBarrierNV at %p: GAPII re-entered. Just invoking imported function at %p", glBlendBarrierNV, s->GlesSpy::imports().glBlendBarrierNV);
        s->GlesSpy::imports().glBlendBarrierNV();
        GAPID_DEBUG("glBlendBarrierNV() -- done");
    }
}
EXPORT void STDCALL glBlendEquationSeparateiOES(DrawBufferIndex buf, uint32_t modeRGB, uint32_t modeAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationSeparateiOES(%" PRIu32 ", %u, %u)", buf, modeRGB, modeAlpha);
    if (s->enter("glBlendEquationSeparateiOES")) {
        s->glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha);
        s->exit();
        GAPID_DEBUG("glBlendEquationSeparateiOES() -- done");
    } else {
        GAPID_INFO("glBlendEquationSeparateiOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationSeparateiOES, s->GlesSpy::imports().glBlendEquationSeparateiOES);
        s->GlesSpy::imports().glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha);
        GAPID_DEBUG("glBlendEquationSeparateiOES() -- done");
    }
}
EXPORT void STDCALL glBlendEquationiOES(DrawBufferIndex buf, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationiOES(%" PRIu32 ", %u)", buf, mode);
    if (s->enter("glBlendEquationiOES")) {
        s->glBlendEquationiOES(buf, mode);
        s->exit();
        GAPID_DEBUG("glBlendEquationiOES() -- done");
    } else {
        GAPID_INFO("glBlendEquationiOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationiOES, s->GlesSpy::imports().glBlendEquationiOES);
        s->GlesSpy::imports().glBlendEquationiOES(buf, mode);
        GAPID_DEBUG("glBlendEquationiOES() -- done");
    }
}
EXPORT void STDCALL glBlendFuncSeparateiOES(DrawBufferIndex buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFuncSeparateiOES(%" PRIu32 ", %u, %u, %u, %u)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
    if (s->enter("glBlendFuncSeparateiOES")) {
        s->glBlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
        s->exit();
        GAPID_DEBUG("glBlendFuncSeparateiOES() -- done");
    } else {
        GAPID_INFO("glBlendFuncSeparateiOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFuncSeparateiOES, s->GlesSpy::imports().glBlendFuncSeparateiOES);
        s->GlesSpy::imports().glBlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
        GAPID_DEBUG("glBlendFuncSeparateiOES() -- done");
    }
}
EXPORT void STDCALL glBlendFunciOES(DrawBufferIndex buf, uint32_t src, uint32_t dst) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFunciOES(%" PRIu32 ", %u, %u)", buf, src, dst);
    if (s->enter("glBlendFunciOES")) {
        s->glBlendFunciOES(buf, src, dst);
        s->exit();
        GAPID_DEBUG("glBlendFunciOES() -- done");
    } else {
        GAPID_INFO("glBlendFunciOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFunciOES, s->GlesSpy::imports().glBlendFunciOES);
        s->GlesSpy::imports().glBlendFunciOES(buf, src, dst);
        GAPID_DEBUG("glBlendFunciOES() -- done");
    }
}
EXPORT void STDCALL glBlendParameteriNV(uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendParameteriNV(%u, %" PRId32 ")", pname, value);
    if (s->enter("glBlendParameteriNV")) {
        s->glBlendParameteriNV(pname, value);
        s->exit();
        GAPID_DEBUG("glBlendParameteriNV() -- done");
    } else {
        GAPID_INFO("glBlendParameteriNV at %p: GAPII re-entered. Just invoking imported function at %p", glBlendParameteriNV, s->GlesSpy::imports().glBlendParameteriNV);
        s->GlesSpy::imports().glBlendParameteriNV(pname, value);
        GAPID_DEBUG("glBlendParameteriNV() -- done");
    }
}
EXPORT void STDCALL glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, uint32_t mask, uint32_t filter) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlitFramebufferANGLE(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    if (s->enter("glBlitFramebufferANGLE")) {
        s->glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        s->exit();
        GAPID_DEBUG("glBlitFramebufferANGLE() -- done");
    } else {
        GAPID_INFO("glBlitFramebufferANGLE at %p: GAPII re-entered. Just invoking imported function at %p", glBlitFramebufferANGLE, s->GlesSpy::imports().glBlitFramebufferANGLE);
        s->GlesSpy::imports().glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        GAPID_DEBUG("glBlitFramebufferANGLE() -- done");
    }
}
EXPORT void STDCALL glBlitFramebufferNV(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, uint32_t mask, uint32_t filter) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlitFramebufferNV(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    if (s->enter("glBlitFramebufferNV")) {
        s->glBlitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        s->exit();
        GAPID_DEBUG("glBlitFramebufferNV() -- done");
    } else {
        GAPID_INFO("glBlitFramebufferNV at %p: GAPII re-entered. Just invoking imported function at %p", glBlitFramebufferNV, s->GlesSpy::imports().glBlitFramebufferNV);
        s->GlesSpy::imports().glBlitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        GAPID_DEBUG("glBlitFramebufferNV() -- done");
    }
}
EXPORT void STDCALL glBufferStorageEXT(uint32_t target, GLsizeiptr size, void* data, uint32_t flag) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBufferStorageEXT(%u, %" PRId32 ", %p, %u)", target, size, data, flag);
    if (s->enter("glBufferStorageEXT")) {
        s->glBufferStorageEXT(target, size, data, flag);
        s->exit();
        GAPID_DEBUG("glBufferStorageEXT() -- done");
    } else {
        GAPID_INFO("glBufferStorageEXT at %p: GAPII re-entered. Just invoking imported function at %p", glBufferStorageEXT, s->GlesSpy::imports().glBufferStorageEXT);
        s->GlesSpy::imports().glBufferStorageEXT(target, size, data, flag);
        GAPID_DEBUG("glBufferStorageEXT() -- done");
    }
}
EXPORT uint32_t STDCALL glClientWaitSyncAPPLE(GLsync sync, uint32_t flag, GLuint64 timeout) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClientWaitSyncAPPLE(%p, %u, %" PRIu64 ")", sync, flag, timeout);
    if (s->enter("glClientWaitSyncAPPLE")) {
        auto _result_ = s->glClientWaitSyncAPPLE(sync, flag, timeout);
        s->exit();
        GAPID_DEBUG("glClientWaitSyncAPPLE() -- done");
        return _result_;
    } else {
        GAPID_INFO("glClientWaitSyncAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glClientWaitSyncAPPLE, s->GlesSpy::imports().glClientWaitSyncAPPLE);
        auto _result_ = s->GlesSpy::imports().glClientWaitSyncAPPLE(sync, flag, timeout);
        GAPID_DEBUG("glClientWaitSyncAPPLE() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glColorMaskiOES(DrawBufferIndex index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColorMaskiOES(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", index, r, g, b, a);
    if (s->enter("glColorMaskiOES")) {
        s->glColorMaskiOES(index, r, g, b, a);
        s->exit();
        GAPID_DEBUG("glColorMaskiOES() -- done");
    } else {
        GAPID_INFO("glColorMaskiOES at %p: GAPII re-entered. Just invoking imported function at %p", glColorMaskiOES, s->GlesSpy::imports().glColorMaskiOES);
        s->GlesSpy::imports().glColorMaskiOES(index, r, g, b, a);
        GAPID_DEBUG("glColorMaskiOES() -- done");
    }
}
EXPORT void STDCALL glCompressedTexImage3DOES(uint32_t target, GLint level, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei image_size, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompressedTexImage3DOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)", target, level, internalformat, width, height, depth, border, image_size, data);
    if (s->enter("glCompressedTexImage3DOES")) {
        s->glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, image_size, data);
        s->exit();
        GAPID_DEBUG("glCompressedTexImage3DOES() -- done");
    } else {
        GAPID_INFO("glCompressedTexImage3DOES at %p: GAPII re-entered. Just invoking imported function at %p", glCompressedTexImage3DOES, s->GlesSpy::imports().glCompressedTexImage3DOES);
        s->GlesSpy::imports().glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, image_size, data);
        GAPID_DEBUG("glCompressedTexImage3DOES() -- done");
    }
}
EXPORT void STDCALL glCompressedTexSubImage3DOES(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, GLsizei image_size, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompressedTexSubImage3DOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %" PRId32 ", %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
    if (s->enter("glCompressedTexSubImage3DOES")) {
        s->glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
        s->exit();
        GAPID_DEBUG("glCompressedTexSubImage3DOES() -- done");
    } else {
        GAPID_INFO("glCompressedTexSubImage3DOES at %p: GAPII re-entered. Just invoking imported function at %p", glCompressedTexSubImage3DOES, s->GlesSpy::imports().glCompressedTexSubImage3DOES);
        s->GlesSpy::imports().glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
        GAPID_DEBUG("glCompressedTexSubImage3DOES() -- done");
    }
}
EXPORT void STDCALL glCopyBufferSubDataNV(uint32_t readTarget, uint32_t writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyBufferSubDataNV(%u, %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", readTarget, writeTarget, readOffset, writeOffset, size);
    if (s->enter("glCopyBufferSubDataNV")) {
        s->glCopyBufferSubDataNV(readTarget, writeTarget, readOffset, writeOffset, size);
        s->exit();
        GAPID_DEBUG("glCopyBufferSubDataNV() -- done");
    } else {
        GAPID_INFO("glCopyBufferSubDataNV at %p: GAPII re-entered. Just invoking imported function at %p", glCopyBufferSubDataNV, s->GlesSpy::imports().glCopyBufferSubDataNV);
        s->GlesSpy::imports().glCopyBufferSubDataNV(readTarget, writeTarget, readOffset, writeOffset, size);
        GAPID_DEBUG("glCopyBufferSubDataNV() -- done");
    }
}
EXPORT void STDCALL glCopyImageSubDataOES(GLuint srcName, uint32_t srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, uint32_t dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyImageSubDataOES(%" PRIu32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
    if (s->enter("glCopyImageSubDataOES")) {
        s->glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        s->exit();
        GAPID_DEBUG("glCopyImageSubDataOES() -- done");
    } else {
        GAPID_INFO("glCopyImageSubDataOES at %p: GAPII re-entered. Just invoking imported function at %p", glCopyImageSubDataOES, s->GlesSpy::imports().glCopyImageSubDataOES);
        s->GlesSpy::imports().glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        GAPID_DEBUG("glCopyImageSubDataOES() -- done");
    }
}
EXPORT void STDCALL glCopyPathNV(GLuint resultPath, GLuint srcPath) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyPathNV(%" PRIu32 ", %" PRIu32 ")", resultPath, srcPath);
    if (s->enter("glCopyPathNV")) {
        s->glCopyPathNV(resultPath, srcPath);
        s->exit();
        GAPID_DEBUG("glCopyPathNV() -- done");
    } else {
        GAPID_INFO("glCopyPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glCopyPathNV, s->GlesSpy::imports().glCopyPathNV);
        s->GlesSpy::imports().glCopyPathNV(resultPath, srcPath);
        GAPID_DEBUG("glCopyPathNV() -- done");
    }
}
EXPORT void STDCALL glCopyTexSubImage3DOES(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyTexSubImage3DOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, xoffset, yoffset, zoffset, x, y, width, height);
    if (s->enter("glCopyTexSubImage3DOES")) {
        s->glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
        s->exit();
        GAPID_DEBUG("glCopyTexSubImage3DOES() -- done");
    } else {
        GAPID_INFO("glCopyTexSubImage3DOES at %p: GAPII re-entered. Just invoking imported function at %p", glCopyTexSubImage3DOES, s->GlesSpy::imports().glCopyTexSubImage3DOES);
        s->GlesSpy::imports().glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
        GAPID_DEBUG("glCopyTexSubImage3DOES() -- done");
    }
}
EXPORT void STDCALL glCopyTextureLevelsAPPLE(GLuint destinationTexture, GLuint sourceTexture, GLint sourceBaseLevel, GLsizei sourceLevelCount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyTextureLevelsAPPLE(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")", destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
    if (s->enter("glCopyTextureLevelsAPPLE")) {
        s->glCopyTextureLevelsAPPLE(destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
        s->exit();
        GAPID_DEBUG("glCopyTextureLevelsAPPLE() -- done");
    } else {
        GAPID_INFO("glCopyTextureLevelsAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glCopyTextureLevelsAPPLE, s->GlesSpy::imports().glCopyTextureLevelsAPPLE);
        s->GlesSpy::imports().glCopyTextureLevelsAPPLE(destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
        GAPID_DEBUG("glCopyTextureLevelsAPPLE() -- done");
    }
}
EXPORT void STDCALL glCoverFillPathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
    if (s->enter("glCoverFillPathInstancedNV")) {
        s->glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glCoverFillPathInstancedNV() -- done");
    } else {
        GAPID_INFO("glCoverFillPathInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverFillPathInstancedNV, s->GlesSpy::imports().glCoverFillPathInstancedNV);
        s->GlesSpy::imports().glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
        GAPID_DEBUG("glCoverFillPathInstancedNV() -- done");
    }
}
EXPORT void STDCALL glCoverFillPathNV(GLuint path, uint32_t coverMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverFillPathNV(%" PRIu32 ", %u)", path, coverMode);
    if (s->enter("glCoverFillPathNV")) {
        s->glCoverFillPathNV(path, coverMode);
        s->exit();
        GAPID_DEBUG("glCoverFillPathNV() -- done");
    } else {
        GAPID_INFO("glCoverFillPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverFillPathNV, s->GlesSpy::imports().glCoverFillPathNV);
        s->GlesSpy::imports().glCoverFillPathNV(path, coverMode);
        GAPID_DEBUG("glCoverFillPathNV() -- done");
    }
}
EXPORT void STDCALL glCoverStrokePathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
    if (s->enter("glCoverStrokePathInstancedNV")) {
        s->glCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glCoverStrokePathInstancedNV() -- done");
    } else {
        GAPID_INFO("glCoverStrokePathInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverStrokePathInstancedNV, s->GlesSpy::imports().glCoverStrokePathInstancedNV);
        s->GlesSpy::imports().glCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
        GAPID_DEBUG("glCoverStrokePathInstancedNV() -- done");
    }
}
EXPORT void STDCALL glCoverStrokePathNV(GLuint path, uint32_t coverMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverStrokePathNV(%" PRIu32 ", %u)", path, coverMode);
    if (s->enter("glCoverStrokePathNV")) {
        s->glCoverStrokePathNV(path, coverMode);
        s->exit();
        GAPID_DEBUG("glCoverStrokePathNV() -- done");
    } else {
        GAPID_INFO("glCoverStrokePathNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverStrokePathNV, s->GlesSpy::imports().glCoverStrokePathNV);
        s->GlesSpy::imports().glCoverStrokePathNV(path, coverMode);
        GAPID_DEBUG("glCoverStrokePathNV() -- done");
    }
}
EXPORT void STDCALL glCoverageMaskNV(GLboolean mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageMaskNV(%" PRIu8 ")", mask);
    if (s->enter("glCoverageMaskNV")) {
        s->glCoverageMaskNV(mask);
        s->exit();
        GAPID_DEBUG("glCoverageMaskNV() -- done");
    } else {
        GAPID_INFO("glCoverageMaskNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverageMaskNV, s->GlesSpy::imports().glCoverageMaskNV);
        s->GlesSpy::imports().glCoverageMaskNV(mask);
        GAPID_DEBUG("glCoverageMaskNV() -- done");
    }
}
EXPORT void STDCALL glCoverageModulationNV(uint32_t components) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageModulationNV(%u)", components);
    if (s->enter("glCoverageModulationNV")) {
        s->glCoverageModulationNV(components);
        s->exit();
        GAPID_DEBUG("glCoverageModulationNV() -- done");
    } else {
        GAPID_INFO("glCoverageModulationNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverageModulationNV, s->GlesSpy::imports().glCoverageModulationNV);
        s->GlesSpy::imports().glCoverageModulationNV(components);
        GAPID_DEBUG("glCoverageModulationNV() -- done");
    }
}
EXPORT void STDCALL glCoverageModulationTableNV(GLsizei n, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageModulationTableNV(%" PRId32 ", %p)", n, v);
    if (s->enter("glCoverageModulationTableNV")) {
        s->glCoverageModulationTableNV(n, v);
        s->exit();
        GAPID_DEBUG("glCoverageModulationTableNV() -- done");
    } else {
        GAPID_INFO("glCoverageModulationTableNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverageModulationTableNV, s->GlesSpy::imports().glCoverageModulationTableNV);
        s->GlesSpy::imports().glCoverageModulationTableNV(n, v);
        GAPID_DEBUG("glCoverageModulationTableNV() -- done");
    }
}
EXPORT void STDCALL glCoverageOperationNV(uint32_t operation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageOperationNV(%u)", operation);
    if (s->enter("glCoverageOperationNV")) {
        s->glCoverageOperationNV(operation);
        s->exit();
        GAPID_DEBUG("glCoverageOperationNV() -- done");
    } else {
        GAPID_INFO("glCoverageOperationNV at %p: GAPII re-entered. Just invoking imported function at %p", glCoverageOperationNV, s->GlesSpy::imports().glCoverageOperationNV);
        s->GlesSpy::imports().glCoverageOperationNV(operation);
        GAPID_DEBUG("glCoverageOperationNV() -- done");
    }
}
EXPORT void STDCALL glCreatePerfQueryINTEL(GLuint queryId, GLuint* queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreatePerfQueryINTEL(%" PRIu32 ", %p)", queryId, queryHandle);
    if (s->enter("glCreatePerfQueryINTEL")) {
        s->glCreatePerfQueryINTEL(queryId, queryHandle);
        s->exit();
        GAPID_DEBUG("glCreatePerfQueryINTEL() -- done");
    } else {
        GAPID_INFO("glCreatePerfQueryINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glCreatePerfQueryINTEL, s->GlesSpy::imports().glCreatePerfQueryINTEL);
        s->GlesSpy::imports().glCreatePerfQueryINTEL(queryId, queryHandle);
        GAPID_DEBUG("glCreatePerfQueryINTEL() -- done");
    }
}
EXPORT GLuint STDCALL glCreateShaderProgramvEXT(uint32_t type, GLsizei count, GLchar** strings) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreateShaderProgramvEXT(%u, %" PRId32 ", %p)", type, count, strings);
    if (s->enter("glCreateShaderProgramvEXT")) {
        auto _result_ = s->glCreateShaderProgramvEXT(type, count, strings);
        s->exit();
        GAPID_DEBUG("glCreateShaderProgramvEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glCreateShaderProgramvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glCreateShaderProgramvEXT, s->GlesSpy::imports().glCreateShaderProgramvEXT);
        auto _result_ = s->GlesSpy::imports().glCreateShaderProgramvEXT(type, count, strings);
        GAPID_DEBUG("glCreateShaderProgramvEXT() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glDeleteFencesNV(GLsizei n, GLuint* fences) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteFencesNV(%" PRId32 ", %p)", n, fences);
    if (s->enter("glDeleteFencesNV")) {
        s->glDeleteFencesNV(n, fences);
        s->exit();
        GAPID_DEBUG("glDeleteFencesNV() -- done");
    } else {
        GAPID_INFO("glDeleteFencesNV at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteFencesNV, s->GlesSpy::imports().glDeleteFencesNV);
        s->GlesSpy::imports().glDeleteFencesNV(n, fences);
        GAPID_DEBUG("glDeleteFencesNV() -- done");
    }
}
EXPORT void STDCALL glDeletePathsNV(GLuint path, GLsizei range) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeletePathsNV(%" PRIu32 ", %" PRId32 ")", path, range);
    if (s->enter("glDeletePathsNV")) {
        s->glDeletePathsNV(path, range);
        s->exit();
        GAPID_DEBUG("glDeletePathsNV() -- done");
    } else {
        GAPID_INFO("glDeletePathsNV at %p: GAPII re-entered. Just invoking imported function at %p", glDeletePathsNV, s->GlesSpy::imports().glDeletePathsNV);
        s->GlesSpy::imports().glDeletePathsNV(path, range);
        GAPID_DEBUG("glDeletePathsNV() -- done");
    }
}
EXPORT void STDCALL glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeletePerfMonitorsAMD(%" PRId32 ", %p)", n, monitors);
    if (s->enter("glDeletePerfMonitorsAMD")) {
        s->glDeletePerfMonitorsAMD(n, monitors);
        s->exit();
        GAPID_DEBUG("glDeletePerfMonitorsAMD() -- done");
    } else {
        GAPID_INFO("glDeletePerfMonitorsAMD at %p: GAPII re-entered. Just invoking imported function at %p", glDeletePerfMonitorsAMD, s->GlesSpy::imports().glDeletePerfMonitorsAMD);
        s->GlesSpy::imports().glDeletePerfMonitorsAMD(n, monitors);
        GAPID_DEBUG("glDeletePerfMonitorsAMD() -- done");
    }
}
EXPORT void STDCALL glDeletePerfQueryINTEL(GLuint queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeletePerfQueryINTEL(%" PRIu32 ")", queryHandle);
    if (s->enter("glDeletePerfQueryINTEL")) {
        s->glDeletePerfQueryINTEL(queryHandle);
        s->exit();
        GAPID_DEBUG("glDeletePerfQueryINTEL() -- done");
    } else {
        GAPID_INFO("glDeletePerfQueryINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glDeletePerfQueryINTEL, s->GlesSpy::imports().glDeletePerfQueryINTEL);
        s->GlesSpy::imports().glDeletePerfQueryINTEL(queryHandle);
        GAPID_DEBUG("glDeletePerfQueryINTEL() -- done");
    }
}
EXPORT void STDCALL glDeleteProgramPipelinesEXT(GLsizei n, PipelineId* pipelines) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteProgramPipelinesEXT(%" PRId32 ", %p)", n, pipelines);
    if (s->enter("glDeleteProgramPipelinesEXT")) {
        s->glDeleteProgramPipelinesEXT(n, pipelines);
        s->exit();
        GAPID_DEBUG("glDeleteProgramPipelinesEXT() -- done");
    } else {
        GAPID_INFO("glDeleteProgramPipelinesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteProgramPipelinesEXT, s->GlesSpy::imports().glDeleteProgramPipelinesEXT);
        s->GlesSpy::imports().glDeleteProgramPipelinesEXT(n, pipelines);
        GAPID_DEBUG("glDeleteProgramPipelinesEXT() -- done");
    }
}
EXPORT void STDCALL glDeleteQueriesEXT(GLsizei count, QueryId* queries) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteQueriesEXT(%" PRId32 ", %p)", count, queries);
    if (s->enter("glDeleteQueriesEXT")) {
        s->glDeleteQueriesEXT(count, queries);
        s->exit();
        GAPID_DEBUG("glDeleteQueriesEXT() -- done");
    } else {
        GAPID_INFO("glDeleteQueriesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteQueriesEXT, s->GlesSpy::imports().glDeleteQueriesEXT);
        s->GlesSpy::imports().glDeleteQueriesEXT(count, queries);
        GAPID_DEBUG("glDeleteQueriesEXT() -- done");
    }
}
EXPORT void STDCALL glDeleteSyncAPPLE(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteSyncAPPLE(%p)", sync);
    if (s->enter("glDeleteSyncAPPLE")) {
        s->glDeleteSyncAPPLE(sync);
        s->exit();
        GAPID_DEBUG("glDeleteSyncAPPLE() -- done");
    } else {
        GAPID_INFO("glDeleteSyncAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteSyncAPPLE, s->GlesSpy::imports().glDeleteSyncAPPLE);
        s->GlesSpy::imports().glDeleteSyncAPPLE(sync);
        GAPID_DEBUG("glDeleteSyncAPPLE() -- done");
    }
}
EXPORT void STDCALL glDeleteVertexArraysOES(GLsizei count, VertexArrayId* arrays) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteVertexArraysOES(%" PRId32 ", %p)", count, arrays);
    if (s->enter("glDeleteVertexArraysOES")) {
        s->glDeleteVertexArraysOES(count, arrays);
        s->exit();
        GAPID_DEBUG("glDeleteVertexArraysOES() -- done");
    } else {
        GAPID_INFO("glDeleteVertexArraysOES at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteVertexArraysOES, s->GlesSpy::imports().glDeleteVertexArraysOES);
        s->GlesSpy::imports().glDeleteVertexArraysOES(count, arrays);
        GAPID_DEBUG("glDeleteVertexArraysOES() -- done");
    }
}
EXPORT void STDCALL glDepthRangeArrayfvNV(GLuint first, GLsizei count, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangeArrayfvNV(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
    if (s->enter("glDepthRangeArrayfvNV")) {
        s->glDepthRangeArrayfvNV(first, count, v);
        s->exit();
        GAPID_DEBUG("glDepthRangeArrayfvNV() -- done");
    } else {
        GAPID_INFO("glDepthRangeArrayfvNV at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangeArrayfvNV, s->GlesSpy::imports().glDepthRangeArrayfvNV);
        s->GlesSpy::imports().glDepthRangeArrayfvNV(first, count, v);
        GAPID_DEBUG("glDepthRangeArrayfvNV() -- done");
    }
}
EXPORT void STDCALL glDepthRangeIndexedfNV(GLuint index, GLfloat n, GLfloat f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangeIndexedfNV(%" PRIu32 ", %f, %f)", index, n, f);
    if (s->enter("glDepthRangeIndexedfNV")) {
        s->glDepthRangeIndexedfNV(index, n, f);
        s->exit();
        GAPID_DEBUG("glDepthRangeIndexedfNV() -- done");
    } else {
        GAPID_INFO("glDepthRangeIndexedfNV at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangeIndexedfNV, s->GlesSpy::imports().glDepthRangeIndexedfNV);
        s->GlesSpy::imports().glDepthRangeIndexedfNV(index, n, f);
        GAPID_DEBUG("glDepthRangeIndexedfNV() -- done");
    }
}
EXPORT void STDCALL glDisableDriverControlQCOM(GLuint driverControl) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableDriverControlQCOM(%" PRIu32 ")", driverControl);
    if (s->enter("glDisableDriverControlQCOM")) {
        s->glDisableDriverControlQCOM(driverControl);
        s->exit();
        GAPID_DEBUG("glDisableDriverControlQCOM() -- done");
    } else {
        GAPID_INFO("glDisableDriverControlQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glDisableDriverControlQCOM, s->GlesSpy::imports().glDisableDriverControlQCOM);
        s->GlesSpy::imports().glDisableDriverControlQCOM(driverControl);
        GAPID_DEBUG("glDisableDriverControlQCOM() -- done");
    }
}
EXPORT void STDCALL glDisableiNV(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableiNV(%u, %" PRIu32 ")", target, index);
    if (s->enter("glDisableiNV")) {
        s->glDisableiNV(target, index);
        s->exit();
        GAPID_DEBUG("glDisableiNV() -- done");
    } else {
        GAPID_INFO("glDisableiNV at %p: GAPII re-entered. Just invoking imported function at %p", glDisableiNV, s->GlesSpy::imports().glDisableiNV);
        s->GlesSpy::imports().glDisableiNV(target, index);
        GAPID_DEBUG("glDisableiNV() -- done");
    }
}
EXPORT void STDCALL glDisableiOES(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableiOES(%u, %" PRIu32 ")", target, index);
    if (s->enter("glDisableiOES")) {
        s->glDisableiOES(target, index);
        s->exit();
        GAPID_DEBUG("glDisableiOES() -- done");
    } else {
        GAPID_INFO("glDisableiOES at %p: GAPII re-entered. Just invoking imported function at %p", glDisableiOES, s->GlesSpy::imports().glDisableiOES);
        s->GlesSpy::imports().glDisableiOES(target, index);
        GAPID_DEBUG("glDisableiOES() -- done");
    }
}
EXPORT void STDCALL glDiscardFramebufferEXT(uint32_t target, GLsizei numAttachments, uint32_t* attachments) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDiscardFramebufferEXT(%u, %" PRId32 ", %p)", target, numAttachments, attachments);
    if (s->enter("glDiscardFramebufferEXT")) {
        s->glDiscardFramebufferEXT(target, numAttachments, attachments);
        s->exit();
        GAPID_DEBUG("glDiscardFramebufferEXT() -- done");
    } else {
        GAPID_INFO("glDiscardFramebufferEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDiscardFramebufferEXT, s->GlesSpy::imports().glDiscardFramebufferEXT);
        s->GlesSpy::imports().glDiscardFramebufferEXT(target, numAttachments, attachments);
        GAPID_DEBUG("glDiscardFramebufferEXT() -- done");
    }
}
EXPORT void STDCALL glDrawArraysInstancedANGLE(uint32_t mode, GLint first, GLsizei count, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArraysInstancedANGLE(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", mode, first, count, primcount);
    if (s->enter("glDrawArraysInstancedANGLE")) {
        s->glDrawArraysInstancedANGLE(mode, first, count, primcount);
        s->exit();
        GAPID_DEBUG("glDrawArraysInstancedANGLE() -- done");
    } else {
        GAPID_INFO("glDrawArraysInstancedANGLE at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArraysInstancedANGLE, s->GlesSpy::imports().glDrawArraysInstancedANGLE);
        s->GlesSpy::imports().glDrawArraysInstancedANGLE(mode, first, count, primcount);
        GAPID_DEBUG("glDrawArraysInstancedANGLE() -- done");
    }
}
EXPORT void STDCALL glDrawArraysInstancedBaseInstanceEXT(uint32_t mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArraysInstancedBaseInstanceEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu32 ")", mode, first, count, instancecount, baseinstance);
    if (s->enter("glDrawArraysInstancedBaseInstanceEXT")) {
        s->glDrawArraysInstancedBaseInstanceEXT(mode, first, count, instancecount, baseinstance);
        s->exit();
        GAPID_DEBUG("glDrawArraysInstancedBaseInstanceEXT() -- done");
    } else {
        GAPID_INFO("glDrawArraysInstancedBaseInstanceEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArraysInstancedBaseInstanceEXT, s->GlesSpy::imports().glDrawArraysInstancedBaseInstanceEXT);
        s->GlesSpy::imports().glDrawArraysInstancedBaseInstanceEXT(mode, first, count, instancecount, baseinstance);
        GAPID_DEBUG("glDrawArraysInstancedBaseInstanceEXT() -- done");
    }
}
EXPORT void STDCALL glDrawArraysInstancedEXT(uint32_t mode, GLint start, GLsizei count, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArraysInstancedEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", mode, start, count, primcount);
    if (s->enter("glDrawArraysInstancedEXT")) {
        s->glDrawArraysInstancedEXT(mode, start, count, primcount);
        s->exit();
        GAPID_DEBUG("glDrawArraysInstancedEXT() -- done");
    } else {
        GAPID_INFO("glDrawArraysInstancedEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArraysInstancedEXT, s->GlesSpy::imports().glDrawArraysInstancedEXT);
        s->GlesSpy::imports().glDrawArraysInstancedEXT(mode, start, count, primcount);
        GAPID_DEBUG("glDrawArraysInstancedEXT() -- done");
    }
}
EXPORT void STDCALL glDrawArraysInstancedNV(uint32_t mode, GLint first, GLsizei count, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawArraysInstancedNV(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", mode, first, count, primcount);
    if (s->enter("glDrawArraysInstancedNV")) {
        s->glDrawArraysInstancedNV(mode, first, count, primcount);
        s->exit();
        GAPID_DEBUG("glDrawArraysInstancedNV() -- done");
    } else {
        GAPID_INFO("glDrawArraysInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glDrawArraysInstancedNV, s->GlesSpy::imports().glDrawArraysInstancedNV);
        s->GlesSpy::imports().glDrawArraysInstancedNV(mode, first, count, primcount);
        GAPID_DEBUG("glDrawArraysInstancedNV() -- done");
    }
}
EXPORT void STDCALL glDrawBuffersEXT(GLsizei n, uint32_t* bufs) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawBuffersEXT(%" PRId32 ", %p)", n, bufs);
    if (s->enter("glDrawBuffersEXT")) {
        s->glDrawBuffersEXT(n, bufs);
        s->exit();
        GAPID_DEBUG("glDrawBuffersEXT() -- done");
    } else {
        GAPID_INFO("glDrawBuffersEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawBuffersEXT, s->GlesSpy::imports().glDrawBuffersEXT);
        s->GlesSpy::imports().glDrawBuffersEXT(n, bufs);
        GAPID_DEBUG("glDrawBuffersEXT() -- done");
    }
}
EXPORT void STDCALL glDrawBuffersIndexedEXT(GLint n, uint32_t* location, GLint* indices) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawBuffersIndexedEXT(%" PRId32 ", %p, %p)", n, location, indices);
    if (s->enter("glDrawBuffersIndexedEXT")) {
        s->glDrawBuffersIndexedEXT(n, location, indices);
        s->exit();
        GAPID_DEBUG("glDrawBuffersIndexedEXT() -- done");
    } else {
        GAPID_INFO("glDrawBuffersIndexedEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawBuffersIndexedEXT, s->GlesSpy::imports().glDrawBuffersIndexedEXT);
        s->GlesSpy::imports().glDrawBuffersIndexedEXT(n, location, indices);
        GAPID_DEBUG("glDrawBuffersIndexedEXT() -- done");
    }
}
EXPORT void STDCALL glDrawBuffersNV(GLsizei n, uint32_t* bufs) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawBuffersNV(%" PRId32 ", %p)", n, bufs);
    if (s->enter("glDrawBuffersNV")) {
        s->glDrawBuffersNV(n, bufs);
        s->exit();
        GAPID_DEBUG("glDrawBuffersNV() -- done");
    } else {
        GAPID_INFO("glDrawBuffersNV at %p: GAPII re-entered. Just invoking imported function at %p", glDrawBuffersNV, s->GlesSpy::imports().glDrawBuffersNV);
        s->GlesSpy::imports().glDrawBuffersNV(n, bufs);
        GAPID_DEBUG("glDrawBuffersNV() -- done");
    }
}
EXPORT void STDCALL glDrawElementsBaseVertexEXT(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsBaseVertexEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, basevertex);
    if (s->enter("glDrawElementsBaseVertexEXT")) {
        s->glDrawElementsBaseVertexEXT(mode, count, type, indices, basevertex);
        s->exit();
        GAPID_DEBUG("glDrawElementsBaseVertexEXT() -- done");
    } else {
        GAPID_INFO("glDrawElementsBaseVertexEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsBaseVertexEXT, s->GlesSpy::imports().glDrawElementsBaseVertexEXT);
        s->GlesSpy::imports().glDrawElementsBaseVertexEXT(mode, count, type, indices, basevertex);
        GAPID_DEBUG("glDrawElementsBaseVertexEXT() -- done");
    }
}
EXPORT void STDCALL glDrawElementsBaseVertexOES(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsBaseVertexOES(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, basevertex);
    if (s->enter("glDrawElementsBaseVertexOES")) {
        s->glDrawElementsBaseVertexOES(mode, count, type, indices, basevertex);
        s->exit();
        GAPID_DEBUG("glDrawElementsBaseVertexOES() -- done");
    } else {
        GAPID_INFO("glDrawElementsBaseVertexOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsBaseVertexOES, s->GlesSpy::imports().glDrawElementsBaseVertexOES);
        s->GlesSpy::imports().glDrawElementsBaseVertexOES(mode, count, type, indices, basevertex);
        GAPID_DEBUG("glDrawElementsBaseVertexOES() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedANGLE(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedANGLE(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
    if (s->enter("glDrawElementsInstancedANGLE")) {
        s->glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedANGLE() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedANGLE at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedANGLE, s->GlesSpy::imports().glDrawElementsInstancedANGLE);
        s->GlesSpy::imports().glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
        GAPID_DEBUG("glDrawElementsInstancedANGLE() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedBaseInstanceEXT(uint32_t mode, GLsizei count, uint32_t type, void* indices, GLsizei instancecount, GLuint baseinstance) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedBaseInstanceEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRIu32 ")", mode, count, type, indices, instancecount, baseinstance);
    if (s->enter("glDrawElementsInstancedBaseInstanceEXT")) {
        s->glDrawElementsInstancedBaseInstanceEXT(mode, count, type, indices, instancecount, baseinstance);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedBaseInstanceEXT() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedBaseInstanceEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedBaseInstanceEXT, s->GlesSpy::imports().glDrawElementsInstancedBaseInstanceEXT);
        s->GlesSpy::imports().glDrawElementsInstancedBaseInstanceEXT(mode, count, type, indices, instancecount, baseinstance);
        GAPID_DEBUG("glDrawElementsInstancedBaseInstanceEXT() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedBaseVertexBaseInstanceEXT(uint32_t mode, GLsizei count, uint32_t type, void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedBaseVertexBaseInstanceEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ", %" PRIu32 ")", mode, count, type, indices, instancecount, basevertex, baseinstance);
    if (s->enter("glDrawElementsInstancedBaseVertexBaseInstanceEXT")) {
        s->glDrawElementsInstancedBaseVertexBaseInstanceEXT(mode, count, type, indices, instancecount, basevertex, baseinstance);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedBaseVertexBaseInstanceEXT() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedBaseVertexBaseInstanceEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedBaseVertexBaseInstanceEXT, s->GlesSpy::imports().glDrawElementsInstancedBaseVertexBaseInstanceEXT);
        s->GlesSpy::imports().glDrawElementsInstancedBaseVertexBaseInstanceEXT(mode, count, type, indices, instancecount, basevertex, baseinstance);
        GAPID_DEBUG("glDrawElementsInstancedBaseVertexBaseInstanceEXT() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedBaseVertexEXT(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei instancecount, GLint basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedBaseVertexEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ")", mode, count, type, indices, instancecount, basevertex);
    if (s->enter("glDrawElementsInstancedBaseVertexEXT")) {
        s->glDrawElementsInstancedBaseVertexEXT(mode, count, type, indices, instancecount, basevertex);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedBaseVertexEXT() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedBaseVertexEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedBaseVertexEXT, s->GlesSpy::imports().glDrawElementsInstancedBaseVertexEXT);
        s->GlesSpy::imports().glDrawElementsInstancedBaseVertexEXT(mode, count, type, indices, instancecount, basevertex);
        GAPID_DEBUG("glDrawElementsInstancedBaseVertexEXT() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedBaseVertexOES(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei instancecount, GLint basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedBaseVertexOES(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ")", mode, count, type, indices, instancecount, basevertex);
    if (s->enter("glDrawElementsInstancedBaseVertexOES")) {
        s->glDrawElementsInstancedBaseVertexOES(mode, count, type, indices, instancecount, basevertex);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedBaseVertexOES() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedBaseVertexOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedBaseVertexOES, s->GlesSpy::imports().glDrawElementsInstancedBaseVertexOES);
        s->GlesSpy::imports().glDrawElementsInstancedBaseVertexOES(mode, count, type, indices, instancecount, basevertex);
        GAPID_DEBUG("glDrawElementsInstancedBaseVertexOES() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedEXT(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
    if (s->enter("glDrawElementsInstancedEXT")) {
        s->glDrawElementsInstancedEXT(mode, count, type, indices, primcount);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedEXT() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedEXT, s->GlesSpy::imports().glDrawElementsInstancedEXT);
        s->GlesSpy::imports().glDrawElementsInstancedEXT(mode, count, type, indices, primcount);
        GAPID_DEBUG("glDrawElementsInstancedEXT() -- done");
    }
}
EXPORT void STDCALL glDrawElementsInstancedNV(uint32_t mode, GLsizei count, uint32_t type, IndicesPointer indices, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawElementsInstancedNV(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
    if (s->enter("glDrawElementsInstancedNV")) {
        s->glDrawElementsInstancedNV(mode, count, type, indices, primcount);
        s->exit();
        GAPID_DEBUG("glDrawElementsInstancedNV() -- done");
    } else {
        GAPID_INFO("glDrawElementsInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glDrawElementsInstancedNV, s->GlesSpy::imports().glDrawElementsInstancedNV);
        s->GlesSpy::imports().glDrawElementsInstancedNV(mode, count, type, indices, primcount);
        GAPID_DEBUG("glDrawElementsInstancedNV() -- done");
    }
}
EXPORT void STDCALL glDrawRangeElementsBaseVertexEXT(uint32_t mode, GLuint start, GLuint end, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawRangeElementsBaseVertexEXT(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p, %" PRId32 ")", mode, start, end, count, type, indices, basevertex);
    if (s->enter("glDrawRangeElementsBaseVertexEXT")) {
        s->glDrawRangeElementsBaseVertexEXT(mode, start, end, count, type, indices, basevertex);
        s->exit();
        GAPID_DEBUG("glDrawRangeElementsBaseVertexEXT() -- done");
    } else {
        GAPID_INFO("glDrawRangeElementsBaseVertexEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawRangeElementsBaseVertexEXT, s->GlesSpy::imports().glDrawRangeElementsBaseVertexEXT);
        s->GlesSpy::imports().glDrawRangeElementsBaseVertexEXT(mode, start, end, count, type, indices, basevertex);
        GAPID_DEBUG("glDrawRangeElementsBaseVertexEXT() -- done");
    }
}
EXPORT void STDCALL glDrawRangeElementsBaseVertexOES(uint32_t mode, GLuint start, GLuint end, GLsizei count, uint32_t type, IndicesPointer indices, GLint basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawRangeElementsBaseVertexOES(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p, %" PRId32 ")", mode, start, end, count, type, indices, basevertex);
    if (s->enter("glDrawRangeElementsBaseVertexOES")) {
        s->glDrawRangeElementsBaseVertexOES(mode, start, end, count, type, indices, basevertex);
        s->exit();
        GAPID_DEBUG("glDrawRangeElementsBaseVertexOES() -- done");
    } else {
        GAPID_INFO("glDrawRangeElementsBaseVertexOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawRangeElementsBaseVertexOES, s->GlesSpy::imports().glDrawRangeElementsBaseVertexOES);
        s->GlesSpy::imports().glDrawRangeElementsBaseVertexOES(mode, start, end, count, type, indices, basevertex);
        GAPID_DEBUG("glDrawRangeElementsBaseVertexOES() -- done");
    }
}
EXPORT void STDCALL glEGLImageTargetRenderbufferStorageOES(uint32_t target, GLeglImageOES image) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEGLImageTargetRenderbufferStorageOES(%u, %p)", target, image);
    if (s->enter("glEGLImageTargetRenderbufferStorageOES")) {
        s->glEGLImageTargetRenderbufferStorageOES(target, image);
        s->exit();
        GAPID_DEBUG("glEGLImageTargetRenderbufferStorageOES() -- done");
    } else {
        GAPID_INFO("glEGLImageTargetRenderbufferStorageOES at %p: GAPII re-entered. Just invoking imported function at %p", glEGLImageTargetRenderbufferStorageOES, s->GlesSpy::imports().glEGLImageTargetRenderbufferStorageOES);
        s->GlesSpy::imports().glEGLImageTargetRenderbufferStorageOES(target, image);
        GAPID_DEBUG("glEGLImageTargetRenderbufferStorageOES() -- done");
    }
}
EXPORT void STDCALL glEGLImageTargetTexture2DOES(uint32_t target, GLeglImageOES image) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEGLImageTargetTexture2DOES(%u, %p)", target, image);
    if (s->enter("glEGLImageTargetTexture2DOES")) {
        s->glEGLImageTargetTexture2DOES(target, image);
        s->exit();
        GAPID_DEBUG("glEGLImageTargetTexture2DOES() -- done");
    } else {
        GAPID_INFO("glEGLImageTargetTexture2DOES at %p: GAPII re-entered. Just invoking imported function at %p", glEGLImageTargetTexture2DOES, s->GlesSpy::imports().glEGLImageTargetTexture2DOES);
        s->GlesSpy::imports().glEGLImageTargetTexture2DOES(target, image);
        GAPID_DEBUG("glEGLImageTargetTexture2DOES() -- done");
    }
}
EXPORT void STDCALL glEnableDriverControlQCOM(GLuint driverControl) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableDriverControlQCOM(%" PRIu32 ")", driverControl);
    if (s->enter("glEnableDriverControlQCOM")) {
        s->glEnableDriverControlQCOM(driverControl);
        s->exit();
        GAPID_DEBUG("glEnableDriverControlQCOM() -- done");
    } else {
        GAPID_INFO("glEnableDriverControlQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glEnableDriverControlQCOM, s->GlesSpy::imports().glEnableDriverControlQCOM);
        s->GlesSpy::imports().glEnableDriverControlQCOM(driverControl);
        GAPID_DEBUG("glEnableDriverControlQCOM() -- done");
    }
}
EXPORT void STDCALL glEnableiNV(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableiNV(%u, %" PRIu32 ")", target, index);
    if (s->enter("glEnableiNV")) {
        s->glEnableiNV(target, index);
        s->exit();
        GAPID_DEBUG("glEnableiNV() -- done");
    } else {
        GAPID_INFO("glEnableiNV at %p: GAPII re-entered. Just invoking imported function at %p", glEnableiNV, s->GlesSpy::imports().glEnableiNV);
        s->GlesSpy::imports().glEnableiNV(target, index);
        GAPID_DEBUG("glEnableiNV() -- done");
    }
}
EXPORT void STDCALL glEnableiOES(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableiOES(%u, %" PRIu32 ")", target, index);
    if (s->enter("glEnableiOES")) {
        s->glEnableiOES(target, index);
        s->exit();
        GAPID_DEBUG("glEnableiOES() -- done");
    } else {
        GAPID_INFO("glEnableiOES at %p: GAPII re-entered. Just invoking imported function at %p", glEnableiOES, s->GlesSpy::imports().glEnableiOES);
        s->GlesSpy::imports().glEnableiOES(target, index);
        GAPID_DEBUG("glEnableiOES() -- done");
    }
}
EXPORT void STDCALL glEndConditionalRenderNV() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndConditionalRenderNV()");
    if (s->enter("glEndConditionalRenderNV")) {
        s->glEndConditionalRenderNV();
        s->exit();
        GAPID_DEBUG("glEndConditionalRenderNV() -- done");
    } else {
        GAPID_INFO("glEndConditionalRenderNV at %p: GAPII re-entered. Just invoking imported function at %p", glEndConditionalRenderNV, s->GlesSpy::imports().glEndConditionalRenderNV);
        s->GlesSpy::imports().glEndConditionalRenderNV();
        GAPID_DEBUG("glEndConditionalRenderNV() -- done");
    }
}
EXPORT void STDCALL glEndPerfMonitorAMD(GLuint monitor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndPerfMonitorAMD(%" PRIu32 ")", monitor);
    if (s->enter("glEndPerfMonitorAMD")) {
        s->glEndPerfMonitorAMD(monitor);
        s->exit();
        GAPID_DEBUG("glEndPerfMonitorAMD() -- done");
    } else {
        GAPID_INFO("glEndPerfMonitorAMD at %p: GAPII re-entered. Just invoking imported function at %p", glEndPerfMonitorAMD, s->GlesSpy::imports().glEndPerfMonitorAMD);
        s->GlesSpy::imports().glEndPerfMonitorAMD(monitor);
        GAPID_DEBUG("glEndPerfMonitorAMD() -- done");
    }
}
EXPORT void STDCALL glEndPerfQueryINTEL(GLuint queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndPerfQueryINTEL(%" PRIu32 ")", queryHandle);
    if (s->enter("glEndPerfQueryINTEL")) {
        s->glEndPerfQueryINTEL(queryHandle);
        s->exit();
        GAPID_DEBUG("glEndPerfQueryINTEL() -- done");
    } else {
        GAPID_INFO("glEndPerfQueryINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glEndPerfQueryINTEL, s->GlesSpy::imports().glEndPerfQueryINTEL);
        s->GlesSpy::imports().glEndPerfQueryINTEL(queryHandle);
        GAPID_DEBUG("glEndPerfQueryINTEL() -- done");
    }
}
EXPORT void STDCALL glEndQueryEXT(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndQueryEXT(%u)", target);
    if (s->enter("glEndQueryEXT")) {
        s->glEndQueryEXT(target);
        s->exit();
        GAPID_DEBUG("glEndQueryEXT() -- done");
    } else {
        GAPID_INFO("glEndQueryEXT at %p: GAPII re-entered. Just invoking imported function at %p", glEndQueryEXT, s->GlesSpy::imports().glEndQueryEXT);
        s->GlesSpy::imports().glEndQueryEXT(target);
        GAPID_DEBUG("glEndQueryEXT() -- done");
    }
}
EXPORT void STDCALL glEndTilingQCOM(uint32_t preserve_mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndTilingQCOM(%u)", preserve_mask);
    if (s->enter("glEndTilingQCOM")) {
        s->glEndTilingQCOM(preserve_mask);
        s->exit();
        GAPID_DEBUG("glEndTilingQCOM() -- done");
    } else {
        GAPID_INFO("glEndTilingQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glEndTilingQCOM, s->GlesSpy::imports().glEndTilingQCOM);
        s->GlesSpy::imports().glEndTilingQCOM(preserve_mask);
        GAPID_DEBUG("glEndTilingQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetBufferPointervQCOM(uint32_t target, void** params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetBufferPointervQCOM(%u, %p)", target, params);
    if (s->enter("glExtGetBufferPointervQCOM")) {
        s->glExtGetBufferPointervQCOM(target, params);
        s->exit();
        GAPID_DEBUG("glExtGetBufferPointervQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetBufferPointervQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetBufferPointervQCOM, s->GlesSpy::imports().glExtGetBufferPointervQCOM);
        s->GlesSpy::imports().glExtGetBufferPointervQCOM(target, params);
        GAPID_DEBUG("glExtGetBufferPointervQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetBuffersQCOM(BufferId* buffers, GLint maxBuffers, GLint* numBuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetBuffersQCOM(%p, %" PRId32 ", %p)", buffers, maxBuffers, numBuffers);
    if (s->enter("glExtGetBuffersQCOM")) {
        s->glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
        s->exit();
        GAPID_DEBUG("glExtGetBuffersQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetBuffersQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetBuffersQCOM, s->GlesSpy::imports().glExtGetBuffersQCOM);
        s->GlesSpy::imports().glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
        GAPID_DEBUG("glExtGetBuffersQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetFramebuffersQCOM(FramebufferId* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetFramebuffersQCOM(%p, %" PRId32 ", %p)", framebuffers, maxFramebuffers, numFramebuffers);
    if (s->enter("glExtGetFramebuffersQCOM")) {
        s->glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
        s->exit();
        GAPID_DEBUG("glExtGetFramebuffersQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetFramebuffersQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetFramebuffersQCOM, s->GlesSpy::imports().glExtGetFramebuffersQCOM);
        s->GlesSpy::imports().glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
        GAPID_DEBUG("glExtGetFramebuffersQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetProgramBinarySourceQCOM(ProgramId program, uint32_t shadertype, GLchar* source, GLint* length) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetProgramBinarySourceQCOM(%" PRIu32 ", %u, %p, %p)", program, shadertype, source, length);
    if (s->enter("glExtGetProgramBinarySourceQCOM")) {
        s->glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
        s->exit();
        GAPID_DEBUG("glExtGetProgramBinarySourceQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetProgramBinarySourceQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetProgramBinarySourceQCOM, s->GlesSpy::imports().glExtGetProgramBinarySourceQCOM);
        s->GlesSpy::imports().glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
        GAPID_DEBUG("glExtGetProgramBinarySourceQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetProgramsQCOM(ProgramId* programs, GLint maxPrograms, GLint* numPrograms) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetProgramsQCOM(%p, %" PRId32 ", %p)", programs, maxPrograms, numPrograms);
    if (s->enter("glExtGetProgramsQCOM")) {
        s->glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
        s->exit();
        GAPID_DEBUG("glExtGetProgramsQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetProgramsQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetProgramsQCOM, s->GlesSpy::imports().glExtGetProgramsQCOM);
        s->GlesSpy::imports().glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
        GAPID_DEBUG("glExtGetProgramsQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetRenderbuffersQCOM(RenderbufferId* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetRenderbuffersQCOM(%p, %" PRId32 ", %p)", renderbuffers, maxRenderbuffers, numRenderbuffers);
    if (s->enter("glExtGetRenderbuffersQCOM")) {
        s->glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
        s->exit();
        GAPID_DEBUG("glExtGetRenderbuffersQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetRenderbuffersQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetRenderbuffersQCOM, s->GlesSpy::imports().glExtGetRenderbuffersQCOM);
        s->GlesSpy::imports().glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
        GAPID_DEBUG("glExtGetRenderbuffersQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetShadersQCOM(ShaderId* shaders, GLint maxShaders, GLint* numShaders) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetShadersQCOM(%p, %" PRId32 ", %p)", shaders, maxShaders, numShaders);
    if (s->enter("glExtGetShadersQCOM")) {
        s->glExtGetShadersQCOM(shaders, maxShaders, numShaders);
        s->exit();
        GAPID_DEBUG("glExtGetShadersQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetShadersQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetShadersQCOM, s->GlesSpy::imports().glExtGetShadersQCOM);
        s->GlesSpy::imports().glExtGetShadersQCOM(shaders, maxShaders, numShaders);
        GAPID_DEBUG("glExtGetShadersQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetTexLevelParameterivQCOM(TextureId texture, uint32_t face, GLint level, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetTexLevelParameterivQCOM(%" PRIu32 ", %u, %" PRId32 ", %u, %p)", texture, face, level, pname, params);
    if (s->enter("glExtGetTexLevelParameterivQCOM")) {
        s->glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
        s->exit();
        GAPID_DEBUG("glExtGetTexLevelParameterivQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetTexLevelParameterivQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetTexLevelParameterivQCOM, s->GlesSpy::imports().glExtGetTexLevelParameterivQCOM);
        s->GlesSpy::imports().glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
        GAPID_DEBUG("glExtGetTexLevelParameterivQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetTexSubImageQCOM(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, void* texels) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetTexSubImageQCOM(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
    if (s->enter("glExtGetTexSubImageQCOM")) {
        s->glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
        s->exit();
        GAPID_DEBUG("glExtGetTexSubImageQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetTexSubImageQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetTexSubImageQCOM, s->GlesSpy::imports().glExtGetTexSubImageQCOM);
        s->GlesSpy::imports().glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
        GAPID_DEBUG("glExtGetTexSubImageQCOM() -- done");
    }
}
EXPORT void STDCALL glExtGetTexturesQCOM(TextureId* textures, GLint maxTextures, GLint* numTextures) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtGetTexturesQCOM(%p, %" PRId32 ", %p)", textures, maxTextures, numTextures);
    if (s->enter("glExtGetTexturesQCOM")) {
        s->glExtGetTexturesQCOM(textures, maxTextures, numTextures);
        s->exit();
        GAPID_DEBUG("glExtGetTexturesQCOM() -- done");
    } else {
        GAPID_INFO("glExtGetTexturesQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtGetTexturesQCOM, s->GlesSpy::imports().glExtGetTexturesQCOM);
        s->GlesSpy::imports().glExtGetTexturesQCOM(textures, maxTextures, numTextures);
        GAPID_DEBUG("glExtGetTexturesQCOM() -- done");
    }
}
EXPORT GLboolean STDCALL glExtIsProgramBinaryQCOM(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtIsProgramBinaryQCOM(%" PRIu32 ")", program);
    if (s->enter("glExtIsProgramBinaryQCOM")) {
        auto _result_ = s->glExtIsProgramBinaryQCOM(program);
        s->exit();
        GAPID_DEBUG("glExtIsProgramBinaryQCOM() -- done");
        return _result_;
    } else {
        GAPID_INFO("glExtIsProgramBinaryQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtIsProgramBinaryQCOM, s->GlesSpy::imports().glExtIsProgramBinaryQCOM);
        auto _result_ = s->GlesSpy::imports().glExtIsProgramBinaryQCOM(program);
        GAPID_DEBUG("glExtIsProgramBinaryQCOM() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glExtTexObjectStateOverrideiQCOM(uint32_t target, uint32_t pname, GLint param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtTexObjectStateOverrideiQCOM(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glExtTexObjectStateOverrideiQCOM")) {
        s->glExtTexObjectStateOverrideiQCOM(target, pname, param);
        s->exit();
        GAPID_DEBUG("glExtTexObjectStateOverrideiQCOM() -- done");
    } else {
        GAPID_INFO("glExtTexObjectStateOverrideiQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glExtTexObjectStateOverrideiQCOM, s->GlesSpy::imports().glExtTexObjectStateOverrideiQCOM);
        s->GlesSpy::imports().glExtTexObjectStateOverrideiQCOM(target, pname, param);
        GAPID_DEBUG("glExtTexObjectStateOverrideiQCOM() -- done");
    }
}
EXPORT GLsync STDCALL glFenceSyncAPPLE(uint32_t condition, uint32_t flag) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFenceSyncAPPLE(%u, %u)", condition, flag);
    if (s->enter("glFenceSyncAPPLE")) {
        auto _result_ = s->glFenceSyncAPPLE(condition, flag);
        s->exit();
        GAPID_DEBUG("glFenceSyncAPPLE() -- done");
        return _result_;
    } else {
        GAPID_INFO("glFenceSyncAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glFenceSyncAPPLE, s->GlesSpy::imports().glFenceSyncAPPLE);
        auto _result_ = s->GlesSpy::imports().glFenceSyncAPPLE(condition, flag);
        GAPID_DEBUG("glFenceSyncAPPLE() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glFinishFenceNV(GLuint fence) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFinishFenceNV(%" PRIu32 ")", fence);
    if (s->enter("glFinishFenceNV")) {
        s->glFinishFenceNV(fence);
        s->exit();
        GAPID_DEBUG("glFinishFenceNV() -- done");
    } else {
        GAPID_INFO("glFinishFenceNV at %p: GAPII re-entered. Just invoking imported function at %p", glFinishFenceNV, s->GlesSpy::imports().glFinishFenceNV);
        s->GlesSpy::imports().glFinishFenceNV(fence);
        GAPID_DEBUG("glFinishFenceNV() -- done");
    }
}
EXPORT void STDCALL glFlushMappedBufferRangeEXT(uint32_t target, GLintptr offset, GLsizeiptr length) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFlushMappedBufferRangeEXT(%u, %" PRId32 ", %" PRId32 ")", target, offset, length);
    if (s->enter("glFlushMappedBufferRangeEXT")) {
        s->glFlushMappedBufferRangeEXT(target, offset, length);
        s->exit();
        GAPID_DEBUG("glFlushMappedBufferRangeEXT() -- done");
    } else {
        GAPID_INFO("glFlushMappedBufferRangeEXT at %p: GAPII re-entered. Just invoking imported function at %p", glFlushMappedBufferRangeEXT, s->GlesSpy::imports().glFlushMappedBufferRangeEXT);
        s->GlesSpy::imports().glFlushMappedBufferRangeEXT(target, offset, length);
        GAPID_DEBUG("glFlushMappedBufferRangeEXT() -- done");
    }
}
EXPORT void STDCALL glFragmentCoverageColorNV(GLuint color) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFragmentCoverageColorNV(%" PRIu32 ")", color);
    if (s->enter("glFragmentCoverageColorNV")) {
        s->glFragmentCoverageColorNV(color);
        s->exit();
        GAPID_DEBUG("glFragmentCoverageColorNV() -- done");
    } else {
        GAPID_INFO("glFragmentCoverageColorNV at %p: GAPII re-entered. Just invoking imported function at %p", glFragmentCoverageColorNV, s->GlesSpy::imports().glFragmentCoverageColorNV);
        s->GlesSpy::imports().glFragmentCoverageColorNV(color);
        GAPID_DEBUG("glFragmentCoverageColorNV() -- done");
    }
}
EXPORT void STDCALL glFramebufferSampleLocationsfvNV(uint32_t target, GLuint start, GLsizei count, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferSampleLocationsfvNV(%u, %" PRIu32 ", %" PRId32 ", %p)", target, start, count, v);
    if (s->enter("glFramebufferSampleLocationsfvNV")) {
        s->glFramebufferSampleLocationsfvNV(target, start, count, v);
        s->exit();
        GAPID_DEBUG("glFramebufferSampleLocationsfvNV() -- done");
    } else {
        GAPID_INFO("glFramebufferSampleLocationsfvNV at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferSampleLocationsfvNV, s->GlesSpy::imports().glFramebufferSampleLocationsfvNV);
        s->GlesSpy::imports().glFramebufferSampleLocationsfvNV(target, start, count, v);
        GAPID_DEBUG("glFramebufferSampleLocationsfvNV() -- done");
    }
}
EXPORT void STDCALL glFramebufferTexture2DMultisampleEXT(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level, GLsizei samples) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture2DMultisampleEXT(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, samples);
    if (s->enter("glFramebufferTexture2DMultisampleEXT")) {
        s->glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
        s->exit();
        GAPID_DEBUG("glFramebufferTexture2DMultisampleEXT() -- done");
    } else {
        GAPID_INFO("glFramebufferTexture2DMultisampleEXT at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture2DMultisampleEXT, s->GlesSpy::imports().glFramebufferTexture2DMultisampleEXT);
        s->GlesSpy::imports().glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
        GAPID_DEBUG("glFramebufferTexture2DMultisampleEXT() -- done");
    }
}
EXPORT void STDCALL glFramebufferTexture2DMultisampleIMG(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level, GLsizei samples) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture2DMultisampleIMG(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, samples);
    if (s->enter("glFramebufferTexture2DMultisampleIMG")) {
        s->glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
        s->exit();
        GAPID_DEBUG("glFramebufferTexture2DMultisampleIMG() -- done");
    } else {
        GAPID_INFO("glFramebufferTexture2DMultisampleIMG at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture2DMultisampleIMG, s->GlesSpy::imports().glFramebufferTexture2DMultisampleIMG);
        s->GlesSpy::imports().glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
        GAPID_DEBUG("glFramebufferTexture2DMultisampleIMG() -- done");
    }
}
EXPORT void STDCALL glFramebufferTexture3DOES(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level, GLint zoffset) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture3DOES(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, zoffset);
    if (s->enter("glFramebufferTexture3DOES")) {
        s->glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
        s->exit();
        GAPID_DEBUG("glFramebufferTexture3DOES() -- done");
    } else {
        GAPID_INFO("glFramebufferTexture3DOES at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture3DOES, s->GlesSpy::imports().glFramebufferTexture3DOES);
        s->GlesSpy::imports().glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
        GAPID_DEBUG("glFramebufferTexture3DOES() -- done");
    }
}
EXPORT void STDCALL glFramebufferTextureMultiviewOVR(uint32_t target, uint32_t attachment, TextureId texture, GLint level, GLint baseViewIndex, GLsizei numViews) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTextureMultiviewOVR(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, baseViewIndex, numViews);
    if (s->enter("glFramebufferTextureMultiviewOVR")) {
        s->glFramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews);
        s->exit();
        GAPID_DEBUG("glFramebufferTextureMultiviewOVR() -- done");
    } else {
        GAPID_INFO("glFramebufferTextureMultiviewOVR at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTextureMultiviewOVR, s->GlesSpy::imports().glFramebufferTextureMultiviewOVR);
        s->GlesSpy::imports().glFramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews);
        GAPID_DEBUG("glFramebufferTextureMultiviewOVR() -- done");
    }
}
EXPORT void STDCALL glFramebufferTextureOES(uint32_t target, uint32_t attachment, TextureId texture, GLint level) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTextureOES(%u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, texture, level);
    if (s->enter("glFramebufferTextureOES")) {
        s->glFramebufferTextureOES(target, attachment, texture, level);
        s->exit();
        GAPID_DEBUG("glFramebufferTextureOES() -- done");
    } else {
        GAPID_INFO("glFramebufferTextureOES at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTextureOES, s->GlesSpy::imports().glFramebufferTextureOES);
        s->GlesSpy::imports().glFramebufferTextureOES(target, attachment, texture, level);
        GAPID_DEBUG("glFramebufferTextureOES() -- done");
    }
}
EXPORT void STDCALL glGenFencesNV(GLsizei n, GLuint* fences) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenFencesNV(%" PRId32 ", %p)", n, fences);
    if (s->enter("glGenFencesNV")) {
        s->glGenFencesNV(n, fences);
        s->exit();
        GAPID_DEBUG("glGenFencesNV() -- done");
    } else {
        GAPID_INFO("glGenFencesNV at %p: GAPII re-entered. Just invoking imported function at %p", glGenFencesNV, s->GlesSpy::imports().glGenFencesNV);
        s->GlesSpy::imports().glGenFencesNV(n, fences);
        GAPID_DEBUG("glGenFencesNV() -- done");
    }
}
EXPORT GLuint STDCALL glGenPathsNV(GLsizei range) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenPathsNV(%" PRId32 ")", range);
    if (s->enter("glGenPathsNV")) {
        auto _result_ = s->glGenPathsNV(range);
        s->exit();
        GAPID_DEBUG("glGenPathsNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGenPathsNV at %p: GAPII re-entered. Just invoking imported function at %p", glGenPathsNV, s->GlesSpy::imports().glGenPathsNV);
        auto _result_ = s->GlesSpy::imports().glGenPathsNV(range);
        GAPID_DEBUG("glGenPathsNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenPerfMonitorsAMD(%" PRId32 ", %p)", n, monitors);
    if (s->enter("glGenPerfMonitorsAMD")) {
        s->glGenPerfMonitorsAMD(n, monitors);
        s->exit();
        GAPID_DEBUG("glGenPerfMonitorsAMD() -- done");
    } else {
        GAPID_INFO("glGenPerfMonitorsAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGenPerfMonitorsAMD, s->GlesSpy::imports().glGenPerfMonitorsAMD);
        s->GlesSpy::imports().glGenPerfMonitorsAMD(n, monitors);
        GAPID_DEBUG("glGenPerfMonitorsAMD() -- done");
    }
}
EXPORT void STDCALL glGenProgramPipelinesEXT(GLsizei n, PipelineId* pipelines) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenProgramPipelinesEXT(%" PRId32 ", %p)", n, pipelines);
    if (s->enter("glGenProgramPipelinesEXT")) {
        s->glGenProgramPipelinesEXT(n, pipelines);
        s->exit();
        GAPID_DEBUG("glGenProgramPipelinesEXT() -- done");
    } else {
        GAPID_INFO("glGenProgramPipelinesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGenProgramPipelinesEXT, s->GlesSpy::imports().glGenProgramPipelinesEXT);
        s->GlesSpy::imports().glGenProgramPipelinesEXT(n, pipelines);
        GAPID_DEBUG("glGenProgramPipelinesEXT() -- done");
    }
}
EXPORT void STDCALL glGenQueriesEXT(GLsizei count, QueryId* queries) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenQueriesEXT(%" PRId32 ", %p)", count, queries);
    if (s->enter("glGenQueriesEXT")) {
        s->glGenQueriesEXT(count, queries);
        s->exit();
        GAPID_DEBUG("glGenQueriesEXT() -- done");
    } else {
        GAPID_INFO("glGenQueriesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGenQueriesEXT, s->GlesSpy::imports().glGenQueriesEXT);
        s->GlesSpy::imports().glGenQueriesEXT(count, queries);
        GAPID_DEBUG("glGenQueriesEXT() -- done");
    }
}
EXPORT void STDCALL glGenVertexArraysOES(GLsizei count, VertexArrayId* arrays) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenVertexArraysOES(%" PRId32 ", %p)", count, arrays);
    if (s->enter("glGenVertexArraysOES")) {
        s->glGenVertexArraysOES(count, arrays);
        s->exit();
        GAPID_DEBUG("glGenVertexArraysOES() -- done");
    } else {
        GAPID_INFO("glGenVertexArraysOES at %p: GAPII re-entered. Just invoking imported function at %p", glGenVertexArraysOES, s->GlesSpy::imports().glGenVertexArraysOES);
        s->GlesSpy::imports().glGenVertexArraysOES(count, arrays);
        GAPID_DEBUG("glGenVertexArraysOES() -- done");
    }
}
EXPORT void STDCALL glGetBufferPointervOES(uint32_t target, uint32_t pname, void** params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetBufferPointervOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetBufferPointervOES")) {
        s->glGetBufferPointervOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetBufferPointervOES() -- done");
    } else {
        GAPID_INFO("glGetBufferPointervOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetBufferPointervOES, s->GlesSpy::imports().glGetBufferPointervOES);
        s->GlesSpy::imports().glGetBufferPointervOES(target, pname, params);
        GAPID_DEBUG("glGetBufferPointervOES() -- done");
    }
}
EXPORT void STDCALL glGetCoverageModulationTableNV(GLsizei bufsize, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetCoverageModulationTableNV(%" PRId32 ", %p)", bufsize, v);
    if (s->enter("glGetCoverageModulationTableNV")) {
        s->glGetCoverageModulationTableNV(bufsize, v);
        s->exit();
        GAPID_DEBUG("glGetCoverageModulationTableNV() -- done");
    } else {
        GAPID_INFO("glGetCoverageModulationTableNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetCoverageModulationTableNV, s->GlesSpy::imports().glGetCoverageModulationTableNV);
        s->GlesSpy::imports().glGetCoverageModulationTableNV(bufsize, v);
        GAPID_DEBUG("glGetCoverageModulationTableNV() -- done");
    }
}
EXPORT void STDCALL glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetDriverControlStringQCOM(%" PRIu32 ", %" PRId32 ", %p, %p)", driverControl, bufSize, length, driverControlString);
    if (s->enter("glGetDriverControlStringQCOM")) {
        s->glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
        s->exit();
        GAPID_DEBUG("glGetDriverControlStringQCOM() -- done");
    } else {
        GAPID_INFO("glGetDriverControlStringQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glGetDriverControlStringQCOM, s->GlesSpy::imports().glGetDriverControlStringQCOM);
        s->GlesSpy::imports().glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
        GAPID_DEBUG("glGetDriverControlStringQCOM() -- done");
    }
}
EXPORT void STDCALL glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetDriverControlsQCOM(%p, %" PRId32 ", %p)", num, size, driverControls);
    if (s->enter("glGetDriverControlsQCOM")) {
        s->glGetDriverControlsQCOM(num, size, driverControls);
        s->exit();
        GAPID_DEBUG("glGetDriverControlsQCOM() -- done");
    } else {
        GAPID_INFO("glGetDriverControlsQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glGetDriverControlsQCOM, s->GlesSpy::imports().glGetDriverControlsQCOM);
        s->GlesSpy::imports().glGetDriverControlsQCOM(num, size, driverControls);
        GAPID_DEBUG("glGetDriverControlsQCOM() -- done");
    }
}
EXPORT void STDCALL glGetFenceivNV(GLuint fence, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFenceivNV(%" PRIu32 ", %u, %p)", fence, pname, params);
    if (s->enter("glGetFenceivNV")) {
        s->glGetFenceivNV(fence, pname, params);
        s->exit();
        GAPID_DEBUG("glGetFenceivNV() -- done");
    } else {
        GAPID_INFO("glGetFenceivNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetFenceivNV, s->GlesSpy::imports().glGetFenceivNV);
        s->GlesSpy::imports().glGetFenceivNV(fence, pname, params);
        GAPID_DEBUG("glGetFenceivNV() -- done");
    }
}
EXPORT void STDCALL glGetFirstPerfQueryIdINTEL(GLuint* queryId) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFirstPerfQueryIdINTEL(%p)", queryId);
    if (s->enter("glGetFirstPerfQueryIdINTEL")) {
        s->glGetFirstPerfQueryIdINTEL(queryId);
        s->exit();
        GAPID_DEBUG("glGetFirstPerfQueryIdINTEL() -- done");
    } else {
        GAPID_INFO("glGetFirstPerfQueryIdINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glGetFirstPerfQueryIdINTEL, s->GlesSpy::imports().glGetFirstPerfQueryIdINTEL);
        s->GlesSpy::imports().glGetFirstPerfQueryIdINTEL(queryId);
        GAPID_DEBUG("glGetFirstPerfQueryIdINTEL() -- done");
    }
}
EXPORT void STDCALL glGetFloati_vNV(uint32_t target, GLuint index, GLfloat* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFloati_vNV(%u, %" PRIu32 ", %p)", target, index, data);
    if (s->enter("glGetFloati_vNV")) {
        s->glGetFloati_vNV(target, index, data);
        s->exit();
        GAPID_DEBUG("glGetFloati_vNV() -- done");
    } else {
        GAPID_INFO("glGetFloati_vNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetFloati_vNV, s->GlesSpy::imports().glGetFloati_vNV);
        s->GlesSpy::imports().glGetFloati_vNV(target, index, data);
        GAPID_DEBUG("glGetFloati_vNV() -- done");
    }
}
EXPORT GLint STDCALL glGetFragDataIndexEXT(ProgramId program, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFragDataIndexEXT(%" PRIu32 ", %s)", program, name);
    if (s->enter("glGetFragDataIndexEXT")) {
        auto _result_ = s->glGetFragDataIndexEXT(program, name);
        s->exit();
        GAPID_DEBUG("glGetFragDataIndexEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetFragDataIndexEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetFragDataIndexEXT, s->GlesSpy::imports().glGetFragDataIndexEXT);
        auto _result_ = s->GlesSpy::imports().glGetFragDataIndexEXT(program, name);
        GAPID_DEBUG("glGetFragDataIndexEXT() -- done");
        return _result_;
    }
}
EXPORT uint32_t STDCALL glGetGraphicsResetStatusEXT() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetGraphicsResetStatusEXT()");
    if (s->enter("glGetGraphicsResetStatusEXT")) {
        auto _result_ = s->glGetGraphicsResetStatusEXT();
        s->exit();
        GAPID_DEBUG("glGetGraphicsResetStatusEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetGraphicsResetStatusEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetGraphicsResetStatusEXT, s->GlesSpy::imports().glGetGraphicsResetStatusEXT);
        auto _result_ = s->GlesSpy::imports().glGetGraphicsResetStatusEXT();
        GAPID_DEBUG("glGetGraphicsResetStatusEXT() -- done");
        return _result_;
    }
}
EXPORT uint32_t STDCALL glGetGraphicsResetStatusKHR() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetGraphicsResetStatusKHR()");
    if (s->enter("glGetGraphicsResetStatusKHR")) {
        auto _result_ = s->glGetGraphicsResetStatusKHR();
        s->exit();
        GAPID_DEBUG("glGetGraphicsResetStatusKHR() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetGraphicsResetStatusKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetGraphicsResetStatusKHR, s->GlesSpy::imports().glGetGraphicsResetStatusKHR);
        auto _result_ = s->GlesSpy::imports().glGetGraphicsResetStatusKHR();
        GAPID_DEBUG("glGetGraphicsResetStatusKHR() -- done");
        return _result_;
    }
}
EXPORT GLuint64 STDCALL glGetImageHandleNV(TextureId texture, GLint level, GLboolean layered, GLint layer, uint32_t format) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetImageHandleNV(%" PRIu32 ", %" PRId32 ", %" PRIu8 ", %" PRId32 ", %u)", texture, level, layered, layer, format);
    if (s->enter("glGetImageHandleNV")) {
        auto _result_ = s->glGetImageHandleNV(texture, level, layered, layer, format);
        s->exit();
        GAPID_DEBUG("glGetImageHandleNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetImageHandleNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetImageHandleNV, s->GlesSpy::imports().glGetImageHandleNV);
        auto _result_ = s->GlesSpy::imports().glGetImageHandleNV(texture, level, layered, layer, format);
        GAPID_DEBUG("glGetImageHandleNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetInteger64vAPPLE(uint32_t pname, GLint64* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetInteger64vAPPLE(%u, %p)", pname, params);
    if (s->enter("glGetInteger64vAPPLE")) {
        s->glGetInteger64vAPPLE(pname, params);
        s->exit();
        GAPID_DEBUG("glGetInteger64vAPPLE() -- done");
    } else {
        GAPID_INFO("glGetInteger64vAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glGetInteger64vAPPLE, s->GlesSpy::imports().glGetInteger64vAPPLE);
        s->GlesSpy::imports().glGetInteger64vAPPLE(pname, params);
        GAPID_DEBUG("glGetInteger64vAPPLE() -- done");
    }
}
EXPORT void STDCALL glGetIntegeri_vEXT(uint32_t target, GLuint index, GLint* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetIntegeri_vEXT(%u, %" PRIu32 ", %p)", target, index, data);
    if (s->enter("glGetIntegeri_vEXT")) {
        s->glGetIntegeri_vEXT(target, index, data);
        s->exit();
        GAPID_DEBUG("glGetIntegeri_vEXT() -- done");
    } else {
        GAPID_INFO("glGetIntegeri_vEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetIntegeri_vEXT, s->GlesSpy::imports().glGetIntegeri_vEXT);
        s->GlesSpy::imports().glGetIntegeri_vEXT(target, index, data);
        GAPID_DEBUG("glGetIntegeri_vEXT() -- done");
    }
}
EXPORT void STDCALL glGetInternalformatSampleivNV(uint32_t target, uint32_t internalformat, GLsizei samples, uint32_t pname, GLsizei bufSize, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetInternalformatSampleivNV(%u, %u, %" PRId32 ", %u, %" PRId32 ", %p)", target, internalformat, samples, pname, bufSize, params);
    if (s->enter("glGetInternalformatSampleivNV")) {
        s->glGetInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetInternalformatSampleivNV() -- done");
    } else {
        GAPID_INFO("glGetInternalformatSampleivNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetInternalformatSampleivNV, s->GlesSpy::imports().glGetInternalformatSampleivNV);
        s->GlesSpy::imports().glGetInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params);
        GAPID_DEBUG("glGetInternalformatSampleivNV() -- done");
    }
}
EXPORT void STDCALL glGetNextPerfQueryIdINTEL(GLuint queryId, GLuint* nextQueryId) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetNextPerfQueryIdINTEL(%" PRIu32 ", %p)", queryId, nextQueryId);
    if (s->enter("glGetNextPerfQueryIdINTEL")) {
        s->glGetNextPerfQueryIdINTEL(queryId, nextQueryId);
        s->exit();
        GAPID_DEBUG("glGetNextPerfQueryIdINTEL() -- done");
    } else {
        GAPID_INFO("glGetNextPerfQueryIdINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glGetNextPerfQueryIdINTEL, s->GlesSpy::imports().glGetNextPerfQueryIdINTEL);
        s->GlesSpy::imports().glGetNextPerfQueryIdINTEL(queryId, nextQueryId);
        GAPID_DEBUG("glGetNextPerfQueryIdINTEL() -- done");
    }
}
EXPORT void STDCALL glGetObjectLabelEXT(uint32_t type, GLuint object, GLsizei bufSize, GLsizei* length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetObjectLabelEXT(%u, %" PRIu32 ", %" PRId32 ", %p, %p)", type, object, bufSize, length, label);
    if (s->enter("glGetObjectLabelEXT")) {
        s->glGetObjectLabelEXT(type, object, bufSize, length, label);
        s->exit();
        GAPID_DEBUG("glGetObjectLabelEXT() -- done");
    } else {
        GAPID_INFO("glGetObjectLabelEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetObjectLabelEXT, s->GlesSpy::imports().glGetObjectLabelEXT);
        s->GlesSpy::imports().glGetObjectLabelEXT(type, object, bufSize, length, label);
        GAPID_DEBUG("glGetObjectLabelEXT() -- done");
    }
}
EXPORT void STDCALL glGetPathCommandsNV(GLuint path, GLubyte* commands) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathCommandsNV(%" PRIu32 ", %p)", path, commands);
    if (s->enter("glGetPathCommandsNV")) {
        s->glGetPathCommandsNV(path, commands);
        s->exit();
        GAPID_DEBUG("glGetPathCommandsNV() -- done");
    } else {
        GAPID_INFO("glGetPathCommandsNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathCommandsNV, s->GlesSpy::imports().glGetPathCommandsNV);
        s->GlesSpy::imports().glGetPathCommandsNV(path, commands);
        GAPID_DEBUG("glGetPathCommandsNV() -- done");
    }
}
EXPORT void STDCALL glGetPathCoordsNV(GLuint path, GLfloat* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathCoordsNV(%" PRIu32 ", %p)", path, coords);
    if (s->enter("glGetPathCoordsNV")) {
        s->glGetPathCoordsNV(path, coords);
        s->exit();
        GAPID_DEBUG("glGetPathCoordsNV() -- done");
    } else {
        GAPID_INFO("glGetPathCoordsNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathCoordsNV, s->GlesSpy::imports().glGetPathCoordsNV);
        s->GlesSpy::imports().glGetPathCoordsNV(path, coords);
        GAPID_DEBUG("glGetPathCoordsNV() -- done");
    }
}
EXPORT void STDCALL glGetPathDashArrayNV(GLuint path, GLfloat* dashArray) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathDashArrayNV(%" PRIu32 ", %p)", path, dashArray);
    if (s->enter("glGetPathDashArrayNV")) {
        s->glGetPathDashArrayNV(path, dashArray);
        s->exit();
        GAPID_DEBUG("glGetPathDashArrayNV() -- done");
    } else {
        GAPID_INFO("glGetPathDashArrayNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathDashArrayNV, s->GlesSpy::imports().glGetPathDashArrayNV);
        s->GlesSpy::imports().glGetPathDashArrayNV(path, dashArray);
        GAPID_DEBUG("glGetPathDashArrayNV() -- done");
    }
}
EXPORT GLfloat STDCALL glGetPathLengthNV(GLuint path, GLsizei startSegment, GLsizei numSegments) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathLengthNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ")", path, startSegment, numSegments);
    if (s->enter("glGetPathLengthNV")) {
        auto _result_ = s->glGetPathLengthNV(path, startSegment, numSegments);
        s->exit();
        GAPID_DEBUG("glGetPathLengthNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetPathLengthNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathLengthNV, s->GlesSpy::imports().glGetPathLengthNV);
        auto _result_ = s->GlesSpy::imports().glGetPathLengthNV(path, startSegment, numSegments);
        GAPID_DEBUG("glGetPathLengthNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetPathMetricRangeNV(uint32_t metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathMetricRangeNV(%u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", metricQueryMask, firstPathName, numPaths, stride, metrics);
    if (s->enter("glGetPathMetricRangeNV")) {
        s->glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
        s->exit();
        GAPID_DEBUG("glGetPathMetricRangeNV() -- done");
    } else {
        GAPID_INFO("glGetPathMetricRangeNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathMetricRangeNV, s->GlesSpy::imports().glGetPathMetricRangeNV);
        s->GlesSpy::imports().glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
        GAPID_DEBUG("glGetPathMetricRangeNV() -- done");
    }
}
EXPORT void STDCALL glGetPathMetricsNV(uint32_t metricQueryMask, GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathMetricsNV(%u, %" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %p)", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
    if (s->enter("glGetPathMetricsNV")) {
        s->glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
        s->exit();
        GAPID_DEBUG("glGetPathMetricsNV() -- done");
    } else {
        GAPID_INFO("glGetPathMetricsNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathMetricsNV, s->GlesSpy::imports().glGetPathMetricsNV);
        s->GlesSpy::imports().glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
        GAPID_DEBUG("glGetPathMetricsNV() -- done");
    }
}
EXPORT void STDCALL glGetPathParameterfvNV(GLuint path, uint32_t pname, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathParameterfvNV(%" PRIu32 ", %u, %p)", path, pname, value);
    if (s->enter("glGetPathParameterfvNV")) {
        s->glGetPathParameterfvNV(path, pname, value);
        s->exit();
        GAPID_DEBUG("glGetPathParameterfvNV() -- done");
    } else {
        GAPID_INFO("glGetPathParameterfvNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathParameterfvNV, s->GlesSpy::imports().glGetPathParameterfvNV);
        s->GlesSpy::imports().glGetPathParameterfvNV(path, pname, value);
        GAPID_DEBUG("glGetPathParameterfvNV() -- done");
    }
}
EXPORT void STDCALL glGetPathParameterivNV(GLuint path, uint32_t pname, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathParameterivNV(%" PRIu32 ", %u, %p)", path, pname, value);
    if (s->enter("glGetPathParameterivNV")) {
        s->glGetPathParameterivNV(path, pname, value);
        s->exit();
        GAPID_DEBUG("glGetPathParameterivNV() -- done");
    } else {
        GAPID_INFO("glGetPathParameterivNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathParameterivNV, s->GlesSpy::imports().glGetPathParameterivNV);
        s->GlesSpy::imports().glGetPathParameterivNV(path, pname, value);
        GAPID_DEBUG("glGetPathParameterivNV() -- done");
    }
}
EXPORT void STDCALL glGetPathSpacingNV(uint32_t pathListMode, GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, uint32_t transformType, GLfloat* returnedSpacing) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPathSpacingNV(%u, %" PRId32 ", %u, %p, %" PRIu32 ", %f, %f, %u, %p)", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
    if (s->enter("glGetPathSpacingNV")) {
        s->glGetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
        s->exit();
        GAPID_DEBUG("glGetPathSpacingNV() -- done");
    } else {
        GAPID_INFO("glGetPathSpacingNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetPathSpacingNV, s->GlesSpy::imports().glGetPathSpacingNV);
        s->GlesSpy::imports().glGetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
        GAPID_DEBUG("glGetPathSpacingNV() -- done");
    }
}
EXPORT void STDCALL glGetPerfCounterInfoINTEL(GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar* counterName, GLuint counterDescLength, GLchar* counterDesc, GLuint* counterOffset, GLuint* counterDataSize, GLuint* counterTypeEnum, GLuint* counterDataTypeEnum, GLuint64* rawCounterMaxValue) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfCounterInfoINTEL(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %p, %" PRIu32 ", %p, %p, %p, %p, %p, %p)", queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
    if (s->enter("glGetPerfCounterInfoINTEL")) {
        s->glGetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
        s->exit();
        GAPID_DEBUG("glGetPerfCounterInfoINTEL() -- done");
    } else {
        GAPID_INFO("glGetPerfCounterInfoINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfCounterInfoINTEL, s->GlesSpy::imports().glGetPerfCounterInfoINTEL);
        s->GlesSpy::imports().glGetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
        GAPID_DEBUG("glGetPerfCounterInfoINTEL() -- done");
    }
}
EXPORT void STDCALL glGetPerfMonitorCounterDataAMD(GLuint monitor, uint32_t pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfMonitorCounterDataAMD(%" PRIu32 ", %u, %" PRId32 ", %p, %p)", monitor, pname, dataSize, data, bytesWritten);
    if (s->enter("glGetPerfMonitorCounterDataAMD")) {
        s->glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
        s->exit();
        GAPID_DEBUG("glGetPerfMonitorCounterDataAMD() -- done");
    } else {
        GAPID_INFO("glGetPerfMonitorCounterDataAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfMonitorCounterDataAMD, s->GlesSpy::imports().glGetPerfMonitorCounterDataAMD);
        s->GlesSpy::imports().glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
        GAPID_DEBUG("glGetPerfMonitorCounterDataAMD() -- done");
    }
}
EXPORT void STDCALL glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, uint32_t pname, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfMonitorCounterInfoAMD(%" PRIu32 ", %" PRIu32 ", %u, %p)", group, counter, pname, data);
    if (s->enter("glGetPerfMonitorCounterInfoAMD")) {
        s->glGetPerfMonitorCounterInfoAMD(group, counter, pname, data);
        s->exit();
        GAPID_DEBUG("glGetPerfMonitorCounterInfoAMD() -- done");
    } else {
        GAPID_INFO("glGetPerfMonitorCounterInfoAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfMonitorCounterInfoAMD, s->GlesSpy::imports().glGetPerfMonitorCounterInfoAMD);
        s->GlesSpy::imports().glGetPerfMonitorCounterInfoAMD(group, counter, pname, data);
        GAPID_DEBUG("glGetPerfMonitorCounterInfoAMD() -- done");
    }
}
EXPORT void STDCALL glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfMonitorCounterStringAMD(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)", group, counter, bufSize, length, counterString);
    if (s->enter("glGetPerfMonitorCounterStringAMD")) {
        s->glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
        s->exit();
        GAPID_DEBUG("glGetPerfMonitorCounterStringAMD() -- done");
    } else {
        GAPID_INFO("glGetPerfMonitorCounterStringAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfMonitorCounterStringAMD, s->GlesSpy::imports().glGetPerfMonitorCounterStringAMD);
        s->GlesSpy::imports().glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
        GAPID_DEBUG("glGetPerfMonitorCounterStringAMD() -- done");
    }
}
EXPORT void STDCALL glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfMonitorCountersAMD(%" PRIu32 ", %p, %p, %" PRId32 ", %p)", group, numCounters, maxActiveCounters, counterSize, counters);
    if (s->enter("glGetPerfMonitorCountersAMD")) {
        s->glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
        s->exit();
        GAPID_DEBUG("glGetPerfMonitorCountersAMD() -- done");
    } else {
        GAPID_INFO("glGetPerfMonitorCountersAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfMonitorCountersAMD, s->GlesSpy::imports().glGetPerfMonitorCountersAMD);
        s->GlesSpy::imports().glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
        GAPID_DEBUG("glGetPerfMonitorCountersAMD() -- done");
    }
}
EXPORT void STDCALL glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfMonitorGroupStringAMD(%" PRIu32 ", %" PRId32 ", %p, %p)", group, bufSize, length, groupString);
    if (s->enter("glGetPerfMonitorGroupStringAMD")) {
        s->glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
        s->exit();
        GAPID_DEBUG("glGetPerfMonitorGroupStringAMD() -- done");
    } else {
        GAPID_INFO("glGetPerfMonitorGroupStringAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfMonitorGroupStringAMD, s->GlesSpy::imports().glGetPerfMonitorGroupStringAMD);
        s->GlesSpy::imports().glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
        GAPID_DEBUG("glGetPerfMonitorGroupStringAMD() -- done");
    }
}
EXPORT void STDCALL glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfMonitorGroupsAMD(%p, %" PRId32 ", %p)", numGroups, groupsSize, groups);
    if (s->enter("glGetPerfMonitorGroupsAMD")) {
        s->glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
        s->exit();
        GAPID_DEBUG("glGetPerfMonitorGroupsAMD() -- done");
    } else {
        GAPID_INFO("glGetPerfMonitorGroupsAMD at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfMonitorGroupsAMD, s->GlesSpy::imports().glGetPerfMonitorGroupsAMD);
        s->GlesSpy::imports().glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
        GAPID_DEBUG("glGetPerfMonitorGroupsAMD() -- done");
    }
}
EXPORT void STDCALL glGetPerfQueryDataINTEL(GLuint queryHandle, GLuint flag, GLsizei dataSize, GLvoid* data, GLuint* bytesWritten) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfQueryDataINTEL(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)", queryHandle, flag, dataSize, data, bytesWritten);
    if (s->enter("glGetPerfQueryDataINTEL")) {
        s->glGetPerfQueryDataINTEL(queryHandle, flag, dataSize, data, bytesWritten);
        s->exit();
        GAPID_DEBUG("glGetPerfQueryDataINTEL() -- done");
    } else {
        GAPID_INFO("glGetPerfQueryDataINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfQueryDataINTEL, s->GlesSpy::imports().glGetPerfQueryDataINTEL);
        s->GlesSpy::imports().glGetPerfQueryDataINTEL(queryHandle, flag, dataSize, data, bytesWritten);
        GAPID_DEBUG("glGetPerfQueryDataINTEL() -- done");
    }
}
EXPORT void STDCALL glGetPerfQueryIdByNameINTEL(GLchar* queryName, GLuint* queryId) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfQueryIdByNameINTEL(%p, %p)", queryName, queryId);
    if (s->enter("glGetPerfQueryIdByNameINTEL")) {
        s->glGetPerfQueryIdByNameINTEL(queryName, queryId);
        s->exit();
        GAPID_DEBUG("glGetPerfQueryIdByNameINTEL() -- done");
    } else {
        GAPID_INFO("glGetPerfQueryIdByNameINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfQueryIdByNameINTEL, s->GlesSpy::imports().glGetPerfQueryIdByNameINTEL);
        s->GlesSpy::imports().glGetPerfQueryIdByNameINTEL(queryName, queryId);
        GAPID_DEBUG("glGetPerfQueryIdByNameINTEL() -- done");
    }
}
EXPORT void STDCALL glGetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, GLchar* queryName, GLuint* dataSize, GLuint* noCounters, GLuint* noInstances, GLuint* capsMask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetPerfQueryInfoINTEL(%" PRIu32 ", %" PRIu32 ", %p, %p, %p, %p, %p)", queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
    if (s->enter("glGetPerfQueryInfoINTEL")) {
        s->glGetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
        s->exit();
        GAPID_DEBUG("glGetPerfQueryInfoINTEL() -- done");
    } else {
        GAPID_INFO("glGetPerfQueryInfoINTEL at %p: GAPII re-entered. Just invoking imported function at %p", glGetPerfQueryInfoINTEL, s->GlesSpy::imports().glGetPerfQueryInfoINTEL);
        s->GlesSpy::imports().glGetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
        GAPID_DEBUG("glGetPerfQueryInfoINTEL() -- done");
    }
}
EXPORT void STDCALL glGetProgramBinaryOES(ProgramId program, GLsizei buffer_size, GLsizei* bytes_written, uint32_t* binary_format, void* binary) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramBinaryOES(%" PRIu32 ", %" PRId32 ", %p, %p, %p)", program, buffer_size, bytes_written, binary_format, binary);
    if (s->enter("glGetProgramBinaryOES")) {
        s->glGetProgramBinaryOES(program, buffer_size, bytes_written, binary_format, binary);
        s->exit();
        GAPID_DEBUG("glGetProgramBinaryOES() -- done");
    } else {
        GAPID_INFO("glGetProgramBinaryOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramBinaryOES, s->GlesSpy::imports().glGetProgramBinaryOES);
        s->GlesSpy::imports().glGetProgramBinaryOES(program, buffer_size, bytes_written, binary_format, binary);
        GAPID_DEBUG("glGetProgramBinaryOES() -- done");
    }
}
EXPORT void STDCALL glGetProgramPipelineInfoLogEXT(PipelineId pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramPipelineInfoLogEXT(%" PRIu32 ", %" PRId32 ", %p, %p)", pipeline, bufSize, length, infoLog);
    if (s->enter("glGetProgramPipelineInfoLogEXT")) {
        s->glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
        s->exit();
        GAPID_DEBUG("glGetProgramPipelineInfoLogEXT() -- done");
    } else {
        GAPID_INFO("glGetProgramPipelineInfoLogEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramPipelineInfoLogEXT, s->GlesSpy::imports().glGetProgramPipelineInfoLogEXT);
        s->GlesSpy::imports().glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
        GAPID_DEBUG("glGetProgramPipelineInfoLogEXT() -- done");
    }
}
EXPORT void STDCALL glGetProgramPipelineivEXT(PipelineId pipeline, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramPipelineivEXT(%" PRIu32 ", %u, %p)", pipeline, pname, params);
    if (s->enter("glGetProgramPipelineivEXT")) {
        s->glGetProgramPipelineivEXT(pipeline, pname, params);
        s->exit();
        GAPID_DEBUG("glGetProgramPipelineivEXT() -- done");
    } else {
        GAPID_INFO("glGetProgramPipelineivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramPipelineivEXT, s->GlesSpy::imports().glGetProgramPipelineivEXT);
        s->GlesSpy::imports().glGetProgramPipelineivEXT(pipeline, pname, params);
        GAPID_DEBUG("glGetProgramPipelineivEXT() -- done");
    }
}
EXPORT GLint STDCALL glGetProgramResourceLocationIndexEXT(ProgramId program, uint32_t programInterface, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramResourceLocationIndexEXT(%" PRIu32 ", %u, %s)", program, programInterface, name);
    if (s->enter("glGetProgramResourceLocationIndexEXT")) {
        auto _result_ = s->glGetProgramResourceLocationIndexEXT(program, programInterface, name);
        s->exit();
        GAPID_DEBUG("glGetProgramResourceLocationIndexEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetProgramResourceLocationIndexEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramResourceLocationIndexEXT, s->GlesSpy::imports().glGetProgramResourceLocationIndexEXT);
        auto _result_ = s->GlesSpy::imports().glGetProgramResourceLocationIndexEXT(program, programInterface, name);
        GAPID_DEBUG("glGetProgramResourceLocationIndexEXT() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetProgramResourcefvNV(ProgramId program, uint32_t programInterface, GLuint index, GLsizei propCount, uint32_t* props, GLsizei bufSize, GLsizei* length, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramResourcefvNV(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %p, %p)", program, programInterface, index, propCount, props, bufSize, length, params);
    if (s->enter("glGetProgramResourcefvNV")) {
        s->glGetProgramResourcefvNV(program, programInterface, index, propCount, props, bufSize, length, params);
        s->exit();
        GAPID_DEBUG("glGetProgramResourcefvNV() -- done");
    } else {
        GAPID_INFO("glGetProgramResourcefvNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramResourcefvNV, s->GlesSpy::imports().glGetProgramResourcefvNV);
        s->GlesSpy::imports().glGetProgramResourcefvNV(program, programInterface, index, propCount, props, bufSize, length, params);
        GAPID_DEBUG("glGetProgramResourcefvNV() -- done");
    }
}
EXPORT void STDCALL glGetQueryObjecti64vEXT(QueryId query, uint32_t parameter, GLint64* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjecti64vEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjecti64vEXT")) {
        s->glGetQueryObjecti64vEXT(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjecti64vEXT() -- done");
    } else {
        GAPID_INFO("glGetQueryObjecti64vEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjecti64vEXT, s->GlesSpy::imports().glGetQueryObjecti64vEXT);
        s->GlesSpy::imports().glGetQueryObjecti64vEXT(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjecti64vEXT() -- done");
    }
}
EXPORT void STDCALL glGetQueryObjectivEXT(QueryId query, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjectivEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjectivEXT")) {
        s->glGetQueryObjectivEXT(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjectivEXT() -- done");
    } else {
        GAPID_INFO("glGetQueryObjectivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjectivEXT, s->GlesSpy::imports().glGetQueryObjectivEXT);
        s->GlesSpy::imports().glGetQueryObjectivEXT(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjectivEXT() -- done");
    }
}
EXPORT void STDCALL glGetQueryObjectui64vEXT(QueryId query, uint32_t parameter, GLuint64* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjectui64vEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjectui64vEXT")) {
        s->glGetQueryObjectui64vEXT(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjectui64vEXT() -- done");
    } else {
        GAPID_INFO("glGetQueryObjectui64vEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjectui64vEXT, s->GlesSpy::imports().glGetQueryObjectui64vEXT);
        s->GlesSpy::imports().glGetQueryObjectui64vEXT(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjectui64vEXT() -- done");
    }
}
EXPORT void STDCALL glGetQueryObjectuivEXT(QueryId query, uint32_t parameter, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjectuivEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjectuivEXT")) {
        s->glGetQueryObjectuivEXT(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjectuivEXT() -- done");
    } else {
        GAPID_INFO("glGetQueryObjectuivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjectuivEXT, s->GlesSpy::imports().glGetQueryObjectuivEXT);
        s->GlesSpy::imports().glGetQueryObjectuivEXT(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjectuivEXT() -- done");
    }
}
EXPORT void STDCALL glGetQueryivEXT(uint32_t target, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryivEXT(%u, %u, %p)", target, parameter, value);
    if (s->enter("glGetQueryivEXT")) {
        s->glGetQueryivEXT(target, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryivEXT() -- done");
    } else {
        GAPID_INFO("glGetQueryivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryivEXT, s->GlesSpy::imports().glGetQueryivEXT);
        s->GlesSpy::imports().glGetQueryivEXT(target, parameter, value);
        GAPID_DEBUG("glGetQueryivEXT() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterIivOES(SamplerId sampler, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterIivOES(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterIivOES")) {
        s->glGetSamplerParameterIivOES(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterIivOES() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterIivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterIivOES, s->GlesSpy::imports().glGetSamplerParameterIivOES);
        s->GlesSpy::imports().glGetSamplerParameterIivOES(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterIivOES() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterIuivOES(SamplerId sampler, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterIuivOES(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterIuivOES")) {
        s->glGetSamplerParameterIuivOES(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterIuivOES() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterIuivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterIuivOES, s->GlesSpy::imports().glGetSamplerParameterIuivOES);
        s->GlesSpy::imports().glGetSamplerParameterIuivOES(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterIuivOES() -- done");
    }
}
EXPORT void STDCALL glGetSyncivAPPLE(GLsync sync, uint32_t pname, GLsizei bufSize, GLsizei* length, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSyncivAPPLE(%p, %u, %" PRId32 ", %p, %p)", sync, pname, bufSize, length, values);
    if (s->enter("glGetSyncivAPPLE")) {
        s->glGetSyncivAPPLE(sync, pname, bufSize, length, values);
        s->exit();
        GAPID_DEBUG("glGetSyncivAPPLE() -- done");
    } else {
        GAPID_INFO("glGetSyncivAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glGetSyncivAPPLE, s->GlesSpy::imports().glGetSyncivAPPLE);
        s->GlesSpy::imports().glGetSyncivAPPLE(sync, pname, bufSize, length, values);
        GAPID_DEBUG("glGetSyncivAPPLE() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterIivOES(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterIivOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterIivOES")) {
        s->glGetTexParameterIivOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterIivOES() -- done");
    } else {
        GAPID_INFO("glGetTexParameterIivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterIivOES, s->GlesSpy::imports().glGetTexParameterIivOES);
        s->GlesSpy::imports().glGetTexParameterIivOES(target, pname, params);
        GAPID_DEBUG("glGetTexParameterIivOES() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterIuivOES(uint32_t target, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterIuivOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterIuivOES")) {
        s->glGetTexParameterIuivOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterIuivOES() -- done");
    } else {
        GAPID_INFO("glGetTexParameterIuivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterIuivOES, s->GlesSpy::imports().glGetTexParameterIuivOES);
        s->GlesSpy::imports().glGetTexParameterIuivOES(target, pname, params);
        GAPID_DEBUG("glGetTexParameterIuivOES() -- done");
    }
}
EXPORT GLuint64 STDCALL glGetTextureHandleNV(TextureId texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTextureHandleNV(%" PRIu32 ")", texture);
    if (s->enter("glGetTextureHandleNV")) {
        auto _result_ = s->glGetTextureHandleNV(texture);
        s->exit();
        GAPID_DEBUG("glGetTextureHandleNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetTextureHandleNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetTextureHandleNV, s->GlesSpy::imports().glGetTextureHandleNV);
        auto _result_ = s->GlesSpy::imports().glGetTextureHandleNV(texture);
        GAPID_DEBUG("glGetTextureHandleNV() -- done");
        return _result_;
    }
}
EXPORT GLuint64 STDCALL glGetTextureSamplerHandleNV(TextureId texture, SamplerId sampler) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTextureSamplerHandleNV(%" PRIu32 ", %" PRIu32 ")", texture, sampler);
    if (s->enter("glGetTextureSamplerHandleNV")) {
        auto _result_ = s->glGetTextureSamplerHandleNV(texture, sampler);
        s->exit();
        GAPID_DEBUG("glGetTextureSamplerHandleNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetTextureSamplerHandleNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetTextureSamplerHandleNV, s->GlesSpy::imports().glGetTextureSamplerHandleNV);
        auto _result_ = s->GlesSpy::imports().glGetTextureSamplerHandleNV(texture, sampler);
        GAPID_DEBUG("glGetTextureSamplerHandleNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetTranslatedShaderSourceANGLE(ShaderId shader, GLsizei bufsize, GLsizei* length, GLchar* source) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTranslatedShaderSourceANGLE(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, bufsize, length, source);
    if (s->enter("glGetTranslatedShaderSourceANGLE")) {
        s->glGetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
        s->exit();
        GAPID_DEBUG("glGetTranslatedShaderSourceANGLE() -- done");
    } else {
        GAPID_INFO("glGetTranslatedShaderSourceANGLE at %p: GAPII re-entered. Just invoking imported function at %p", glGetTranslatedShaderSourceANGLE, s->GlesSpy::imports().glGetTranslatedShaderSourceANGLE);
        s->GlesSpy::imports().glGetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
        GAPID_DEBUG("glGetTranslatedShaderSourceANGLE() -- done");
    }
}
EXPORT void STDCALL glGetnUniformfvEXT(ProgramId program, UniformLocation location, GLsizei bufSize, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformfvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
    if (s->enter("glGetnUniformfvEXT")) {
        s->glGetnUniformfvEXT(program, location, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetnUniformfvEXT() -- done");
    } else {
        GAPID_INFO("glGetnUniformfvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformfvEXT, s->GlesSpy::imports().glGetnUniformfvEXT);
        s->GlesSpy::imports().glGetnUniformfvEXT(program, location, bufSize, params);
        GAPID_DEBUG("glGetnUniformfvEXT() -- done");
    }
}
EXPORT void STDCALL glGetnUniformfvKHR(ProgramId program, UniformLocation location, GLsizei bufSize, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformfvKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
    if (s->enter("glGetnUniformfvKHR")) {
        s->glGetnUniformfvKHR(program, location, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetnUniformfvKHR() -- done");
    } else {
        GAPID_INFO("glGetnUniformfvKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformfvKHR, s->GlesSpy::imports().glGetnUniformfvKHR);
        s->GlesSpy::imports().glGetnUniformfvKHR(program, location, bufSize, params);
        GAPID_DEBUG("glGetnUniformfvKHR() -- done");
    }
}
EXPORT void STDCALL glGetnUniformivEXT(ProgramId program, UniformLocation location, GLsizei bufSize, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
    if (s->enter("glGetnUniformivEXT")) {
        s->glGetnUniformivEXT(program, location, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetnUniformivEXT() -- done");
    } else {
        GAPID_INFO("glGetnUniformivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformivEXT, s->GlesSpy::imports().glGetnUniformivEXT);
        s->GlesSpy::imports().glGetnUniformivEXT(program, location, bufSize, params);
        GAPID_DEBUG("glGetnUniformivEXT() -- done");
    }
}
EXPORT void STDCALL glGetnUniformivKHR(ProgramId program, UniformLocation location, GLsizei bufSize, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformivKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
    if (s->enter("glGetnUniformivKHR")) {
        s->glGetnUniformivKHR(program, location, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetnUniformivKHR() -- done");
    } else {
        GAPID_INFO("glGetnUniformivKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformivKHR, s->GlesSpy::imports().glGetnUniformivKHR);
        s->GlesSpy::imports().glGetnUniformivKHR(program, location, bufSize, params);
        GAPID_DEBUG("glGetnUniformivKHR() -- done");
    }
}
EXPORT void STDCALL glGetnUniformuivKHR(ProgramId program, UniformLocation location, GLsizei bufSize, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformuivKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
    if (s->enter("glGetnUniformuivKHR")) {
        s->glGetnUniformuivKHR(program, location, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetnUniformuivKHR() -- done");
    } else {
        GAPID_INFO("glGetnUniformuivKHR at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformuivKHR, s->GlesSpy::imports().glGetnUniformuivKHR);
        s->GlesSpy::imports().glGetnUniformuivKHR(program, location, bufSize, params);
        GAPID_DEBUG("glGetnUniformuivKHR() -- done");
    }
}
EXPORT void STDCALL glInsertEventMarkerEXT(GLsizei length, GLchar* marker) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glInsertEventMarkerEXT(%" PRId32 ", %p)", length, marker);
    if (s->enter("glInsertEventMarkerEXT")) {
        s->glInsertEventMarkerEXT(length, marker);
        s->exit();
        GAPID_DEBUG("glInsertEventMarkerEXT() -- done");
    } else {
        GAPID_INFO("glInsertEventMarkerEXT at %p: GAPII re-entered. Just invoking imported function at %p", glInsertEventMarkerEXT, s->GlesSpy::imports().glInsertEventMarkerEXT);
        s->GlesSpy::imports().glInsertEventMarkerEXT(length, marker);
        GAPID_DEBUG("glInsertEventMarkerEXT() -- done");
    }
}
EXPORT void STDCALL glInterpolatePathsNV(GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glInterpolatePathsNV(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %f)", resultPath, pathA, pathB, weight);
    if (s->enter("glInterpolatePathsNV")) {
        s->glInterpolatePathsNV(resultPath, pathA, pathB, weight);
        s->exit();
        GAPID_DEBUG("glInterpolatePathsNV() -- done");
    } else {
        GAPID_INFO("glInterpolatePathsNV at %p: GAPII re-entered. Just invoking imported function at %p", glInterpolatePathsNV, s->GlesSpy::imports().glInterpolatePathsNV);
        s->GlesSpy::imports().glInterpolatePathsNV(resultPath, pathA, pathB, weight);
        GAPID_DEBUG("glInterpolatePathsNV() -- done");
    }
}
EXPORT GLboolean STDCALL glIsEnablediNV(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsEnablediNV(%u, %" PRIu32 ")", target, index);
    if (s->enter("glIsEnablediNV")) {
        auto _result_ = s->glIsEnablediNV(target, index);
        s->exit();
        GAPID_DEBUG("glIsEnablediNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsEnablediNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsEnablediNV, s->GlesSpy::imports().glIsEnablediNV);
        auto _result_ = s->GlesSpy::imports().glIsEnablediNV(target, index);
        GAPID_DEBUG("glIsEnablediNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsEnablediOES(uint32_t target, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsEnablediOES(%u, %" PRIu32 ")", target, index);
    if (s->enter("glIsEnablediOES")) {
        auto _result_ = s->glIsEnablediOES(target, index);
        s->exit();
        GAPID_DEBUG("glIsEnablediOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsEnablediOES at %p: GAPII re-entered. Just invoking imported function at %p", glIsEnablediOES, s->GlesSpy::imports().glIsEnablediOES);
        auto _result_ = s->GlesSpy::imports().glIsEnablediOES(target, index);
        GAPID_DEBUG("glIsEnablediOES() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsFenceNV(GLuint fence) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsFenceNV(%" PRIu32 ")", fence);
    if (s->enter("glIsFenceNV")) {
        auto _result_ = s->glIsFenceNV(fence);
        s->exit();
        GAPID_DEBUG("glIsFenceNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsFenceNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsFenceNV, s->GlesSpy::imports().glIsFenceNV);
        auto _result_ = s->GlesSpy::imports().glIsFenceNV(fence);
        GAPID_DEBUG("glIsFenceNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsImageHandleResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsImageHandleResidentNV(%" PRIu64 ")", handle);
    if (s->enter("glIsImageHandleResidentNV")) {
        auto _result_ = s->glIsImageHandleResidentNV(handle);
        s->exit();
        GAPID_DEBUG("glIsImageHandleResidentNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsImageHandleResidentNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsImageHandleResidentNV, s->GlesSpy::imports().glIsImageHandleResidentNV);
        auto _result_ = s->GlesSpy::imports().glIsImageHandleResidentNV(handle);
        GAPID_DEBUG("glIsImageHandleResidentNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsPathNV(GLuint path) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsPathNV(%" PRIu32 ")", path);
    if (s->enter("glIsPathNV")) {
        auto _result_ = s->glIsPathNV(path);
        s->exit();
        GAPID_DEBUG("glIsPathNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsPathNV, s->GlesSpy::imports().glIsPathNV);
        auto _result_ = s->GlesSpy::imports().glIsPathNV(path);
        GAPID_DEBUG("glIsPathNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsPointInFillPathNV(%" PRIu32 ", %" PRIu32 ", %f, %f)", path, mask, x, y);
    if (s->enter("glIsPointInFillPathNV")) {
        auto _result_ = s->glIsPointInFillPathNV(path, mask, x, y);
        s->exit();
        GAPID_DEBUG("glIsPointInFillPathNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsPointInFillPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsPointInFillPathNV, s->GlesSpy::imports().glIsPointInFillPathNV);
        auto _result_ = s->GlesSpy::imports().glIsPointInFillPathNV(path, mask, x, y);
        GAPID_DEBUG("glIsPointInFillPathNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsPointInStrokePathNV(%" PRIu32 ", %f, %f)", path, x, y);
    if (s->enter("glIsPointInStrokePathNV")) {
        auto _result_ = s->glIsPointInStrokePathNV(path, x, y);
        s->exit();
        GAPID_DEBUG("glIsPointInStrokePathNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsPointInStrokePathNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsPointInStrokePathNV, s->GlesSpy::imports().glIsPointInStrokePathNV);
        auto _result_ = s->GlesSpy::imports().glIsPointInStrokePathNV(path, x, y);
        GAPID_DEBUG("glIsPointInStrokePathNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsProgramPipelineEXT(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsProgramPipelineEXT(%" PRIu32 ")", pipeline);
    if (s->enter("glIsProgramPipelineEXT")) {
        auto _result_ = s->glIsProgramPipelineEXT(pipeline);
        s->exit();
        GAPID_DEBUG("glIsProgramPipelineEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsProgramPipelineEXT at %p: GAPII re-entered. Just invoking imported function at %p", glIsProgramPipelineEXT, s->GlesSpy::imports().glIsProgramPipelineEXT);
        auto _result_ = s->GlesSpy::imports().glIsProgramPipelineEXT(pipeline);
        GAPID_DEBUG("glIsProgramPipelineEXT() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsQueryEXT(QueryId query) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsQueryEXT(%" PRIu32 ")", query);
    if (s->enter("glIsQueryEXT")) {
        auto _result_ = s->glIsQueryEXT(query);
        s->exit();
        GAPID_DEBUG("glIsQueryEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsQueryEXT at %p: GAPII re-entered. Just invoking imported function at %p", glIsQueryEXT, s->GlesSpy::imports().glIsQueryEXT);
        auto _result_ = s->GlesSpy::imports().glIsQueryEXT(query);
        GAPID_DEBUG("glIsQueryEXT() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsSyncAPPLE(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsSyncAPPLE(%p)", sync);
    if (s->enter("glIsSyncAPPLE")) {
        auto _result_ = s->glIsSyncAPPLE(sync);
        s->exit();
        GAPID_DEBUG("glIsSyncAPPLE() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsSyncAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glIsSyncAPPLE, s->GlesSpy::imports().glIsSyncAPPLE);
        auto _result_ = s->GlesSpy::imports().glIsSyncAPPLE(sync);
        GAPID_DEBUG("glIsSyncAPPLE() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsTextureHandleResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsTextureHandleResidentNV(%" PRIu64 ")", handle);
    if (s->enter("glIsTextureHandleResidentNV")) {
        auto _result_ = s->glIsTextureHandleResidentNV(handle);
        s->exit();
        GAPID_DEBUG("glIsTextureHandleResidentNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsTextureHandleResidentNV at %p: GAPII re-entered. Just invoking imported function at %p", glIsTextureHandleResidentNV, s->GlesSpy::imports().glIsTextureHandleResidentNV);
        auto _result_ = s->GlesSpy::imports().glIsTextureHandleResidentNV(handle);
        GAPID_DEBUG("glIsTextureHandleResidentNV() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsVertexArrayOES(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsVertexArrayOES(%" PRIu32 ")", array);
    if (s->enter("glIsVertexArrayOES")) {
        auto _result_ = s->glIsVertexArrayOES(array);
        s->exit();
        GAPID_DEBUG("glIsVertexArrayOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsVertexArrayOES at %p: GAPII re-entered. Just invoking imported function at %p", glIsVertexArrayOES, s->GlesSpy::imports().glIsVertexArrayOES);
        auto _result_ = s->GlesSpy::imports().glIsVertexArrayOES(array);
        GAPID_DEBUG("glIsVertexArrayOES() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glLabelObjectEXT(uint32_t type, GLuint object, GLsizei length, GLchar* label) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLabelObjectEXT(%u, %" PRIu32 ", %" PRId32 ", %p)", type, object, length, label);
    if (s->enter("glLabelObjectEXT")) {
        s->glLabelObjectEXT(type, object, length, label);
        s->exit();
        GAPID_DEBUG("glLabelObjectEXT() -- done");
    } else {
        GAPID_INFO("glLabelObjectEXT at %p: GAPII re-entered. Just invoking imported function at %p", glLabelObjectEXT, s->GlesSpy::imports().glLabelObjectEXT);
        s->GlesSpy::imports().glLabelObjectEXT(type, object, length, label);
        GAPID_DEBUG("glLabelObjectEXT() -- done");
    }
}
EXPORT void STDCALL glMakeImageHandleNonResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeImageHandleNonResidentNV(%" PRIu64 ")", handle);
    if (s->enter("glMakeImageHandleNonResidentNV")) {
        s->glMakeImageHandleNonResidentNV(handle);
        s->exit();
        GAPID_DEBUG("glMakeImageHandleNonResidentNV() -- done");
    } else {
        GAPID_INFO("glMakeImageHandleNonResidentNV at %p: GAPII re-entered. Just invoking imported function at %p", glMakeImageHandleNonResidentNV, s->GlesSpy::imports().glMakeImageHandleNonResidentNV);
        s->GlesSpy::imports().glMakeImageHandleNonResidentNV(handle);
        GAPID_DEBUG("glMakeImageHandleNonResidentNV() -- done");
    }
}
EXPORT void STDCALL glMakeImageHandleResidentNV(GLuint64 handle, uint32_t access) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeImageHandleResidentNV(%" PRIu64 ", %u)", handle, access);
    if (s->enter("glMakeImageHandleResidentNV")) {
        s->glMakeImageHandleResidentNV(handle, access);
        s->exit();
        GAPID_DEBUG("glMakeImageHandleResidentNV() -- done");
    } else {
        GAPID_INFO("glMakeImageHandleResidentNV at %p: GAPII re-entered. Just invoking imported function at %p", glMakeImageHandleResidentNV, s->GlesSpy::imports().glMakeImageHandleResidentNV);
        s->GlesSpy::imports().glMakeImageHandleResidentNV(handle, access);
        GAPID_DEBUG("glMakeImageHandleResidentNV() -- done");
    }
}
EXPORT void STDCALL glMakeTextureHandleNonResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeTextureHandleNonResidentNV(%" PRIu64 ")", handle);
    if (s->enter("glMakeTextureHandleNonResidentNV")) {
        s->glMakeTextureHandleNonResidentNV(handle);
        s->exit();
        GAPID_DEBUG("glMakeTextureHandleNonResidentNV() -- done");
    } else {
        GAPID_INFO("glMakeTextureHandleNonResidentNV at %p: GAPII re-entered. Just invoking imported function at %p", glMakeTextureHandleNonResidentNV, s->GlesSpy::imports().glMakeTextureHandleNonResidentNV);
        s->GlesSpy::imports().glMakeTextureHandleNonResidentNV(handle);
        GAPID_DEBUG("glMakeTextureHandleNonResidentNV() -- done");
    }
}
EXPORT void STDCALL glMakeTextureHandleResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeTextureHandleResidentNV(%" PRIu64 ")", handle);
    if (s->enter("glMakeTextureHandleResidentNV")) {
        s->glMakeTextureHandleResidentNV(handle);
        s->exit();
        GAPID_DEBUG("glMakeTextureHandleResidentNV() -- done");
    } else {
        GAPID_INFO("glMakeTextureHandleResidentNV at %p: GAPII re-entered. Just invoking imported function at %p", glMakeTextureHandleResidentNV, s->GlesSpy::imports().glMakeTextureHandleResidentNV);
        s->GlesSpy::imports().glMakeTextureHandleResidentNV(handle);
        GAPID_DEBUG("glMakeTextureHandleResidentNV() -- done");
    }
}
EXPORT void* STDCALL glMapBufferOES(uint32_t target, uint32_t access) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMapBufferOES(%u, %u)", target, access);
    if (s->enter("glMapBufferOES")) {
        auto _result_ = s->glMapBufferOES(target, access);
        s->exit();
        GAPID_DEBUG("glMapBufferOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glMapBufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glMapBufferOES, s->GlesSpy::imports().glMapBufferOES);
        auto _result_ = s->GlesSpy::imports().glMapBufferOES(target, access);
        GAPID_DEBUG("glMapBufferOES() -- done");
        return _result_;
    }
}
EXPORT void* STDCALL glMapBufferRangeEXT(uint32_t target, GLintptr offset, GLsizeiptr length, uint32_t access) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMapBufferRangeEXT(%u, %" PRId32 ", %" PRId32 ", %u)", target, offset, length, access);
    if (s->enter("glMapBufferRangeEXT")) {
        auto _result_ = s->glMapBufferRangeEXT(target, offset, length, access);
        s->exit();
        GAPID_DEBUG("glMapBufferRangeEXT() -- done");
        return _result_;
    } else {
        GAPID_INFO("glMapBufferRangeEXT at %p: GAPII re-entered. Just invoking imported function at %p", glMapBufferRangeEXT, s->GlesSpy::imports().glMapBufferRangeEXT);
        auto _result_ = s->GlesSpy::imports().glMapBufferRangeEXT(target, offset, length, access);
        GAPID_DEBUG("glMapBufferRangeEXT() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glMatrixLoad3x2fNV(uint32_t matrixMode, GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixLoad3x2fNV(%u, %p)", matrixMode, m);
    if (s->enter("glMatrixLoad3x2fNV")) {
        s->glMatrixLoad3x2fNV(matrixMode, m);
        s->exit();
        GAPID_DEBUG("glMatrixLoad3x2fNV() -- done");
    } else {
        GAPID_INFO("glMatrixLoad3x2fNV at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixLoad3x2fNV, s->GlesSpy::imports().glMatrixLoad3x2fNV);
        s->GlesSpy::imports().glMatrixLoad3x2fNV(matrixMode, m);
        GAPID_DEBUG("glMatrixLoad3x2fNV() -- done");
    }
}
EXPORT void STDCALL glMatrixLoad3x3fNV(uint32_t matrixMode, GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixLoad3x3fNV(%u, %p)", matrixMode, m);
    if (s->enter("glMatrixLoad3x3fNV")) {
        s->glMatrixLoad3x3fNV(matrixMode, m);
        s->exit();
        GAPID_DEBUG("glMatrixLoad3x3fNV() -- done");
    } else {
        GAPID_INFO("glMatrixLoad3x3fNV at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixLoad3x3fNV, s->GlesSpy::imports().glMatrixLoad3x3fNV);
        s->GlesSpy::imports().glMatrixLoad3x3fNV(matrixMode, m);
        GAPID_DEBUG("glMatrixLoad3x3fNV() -- done");
    }
}
EXPORT void STDCALL glMatrixLoadTranspose3x3fNV(uint32_t matrixMode, GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixLoadTranspose3x3fNV(%u, %p)", matrixMode, m);
    if (s->enter("glMatrixLoadTranspose3x3fNV")) {
        s->glMatrixLoadTranspose3x3fNV(matrixMode, m);
        s->exit();
        GAPID_DEBUG("glMatrixLoadTranspose3x3fNV() -- done");
    } else {
        GAPID_INFO("glMatrixLoadTranspose3x3fNV at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixLoadTranspose3x3fNV, s->GlesSpy::imports().glMatrixLoadTranspose3x3fNV);
        s->GlesSpy::imports().glMatrixLoadTranspose3x3fNV(matrixMode, m);
        GAPID_DEBUG("glMatrixLoadTranspose3x3fNV() -- done");
    }
}
EXPORT void STDCALL glMatrixMult3x2fNV(uint32_t matrixMode, GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixMult3x2fNV(%u, %p)", matrixMode, m);
    if (s->enter("glMatrixMult3x2fNV")) {
        s->glMatrixMult3x2fNV(matrixMode, m);
        s->exit();
        GAPID_DEBUG("glMatrixMult3x2fNV() -- done");
    } else {
        GAPID_INFO("glMatrixMult3x2fNV at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixMult3x2fNV, s->GlesSpy::imports().glMatrixMult3x2fNV);
        s->GlesSpy::imports().glMatrixMult3x2fNV(matrixMode, m);
        GAPID_DEBUG("glMatrixMult3x2fNV() -- done");
    }
}
EXPORT void STDCALL glMatrixMult3x3fNV(uint32_t matrixMode, GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixMult3x3fNV(%u, %p)", matrixMode, m);
    if (s->enter("glMatrixMult3x3fNV")) {
        s->glMatrixMult3x3fNV(matrixMode, m);
        s->exit();
        GAPID_DEBUG("glMatrixMult3x3fNV() -- done");
    } else {
        GAPID_INFO("glMatrixMult3x3fNV at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixMult3x3fNV, s->GlesSpy::imports().glMatrixMult3x3fNV);
        s->GlesSpy::imports().glMatrixMult3x3fNV(matrixMode, m);
        GAPID_DEBUG("glMatrixMult3x3fNV() -- done");
    }
}
EXPORT void STDCALL glMatrixMultTranspose3x3fNV(uint32_t matrixMode, GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixMultTranspose3x3fNV(%u, %p)", matrixMode, m);
    if (s->enter("glMatrixMultTranspose3x3fNV")) {
        s->glMatrixMultTranspose3x3fNV(matrixMode, m);
        s->exit();
        GAPID_DEBUG("glMatrixMultTranspose3x3fNV() -- done");
    } else {
        GAPID_INFO("glMatrixMultTranspose3x3fNV at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixMultTranspose3x3fNV, s->GlesSpy::imports().glMatrixMultTranspose3x3fNV);
        s->GlesSpy::imports().glMatrixMultTranspose3x3fNV(matrixMode, m);
        GAPID_DEBUG("glMatrixMultTranspose3x3fNV() -- done");
    }
}
EXPORT void STDCALL glMultiDrawArraysEXT(uint32_t mode, GLint* first, GLsizei* count, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiDrawArraysEXT(%u, %p, %p, %" PRId32 ")", mode, first, count, primcount);
    if (s->enter("glMultiDrawArraysEXT")) {
        s->glMultiDrawArraysEXT(mode, first, count, primcount);
        s->exit();
        GAPID_DEBUG("glMultiDrawArraysEXT() -- done");
    } else {
        GAPID_INFO("glMultiDrawArraysEXT at %p: GAPII re-entered. Just invoking imported function at %p", glMultiDrawArraysEXT, s->GlesSpy::imports().glMultiDrawArraysEXT);
        s->GlesSpy::imports().glMultiDrawArraysEXT(mode, first, count, primcount);
        GAPID_DEBUG("glMultiDrawArraysEXT() -- done");
    }
}
EXPORT void STDCALL glMultiDrawArraysIndirectEXT(uint32_t mode, void* indirect, GLsizei drawcount, GLsizei stride) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiDrawArraysIndirectEXT(%u, %p, %" PRId32 ", %" PRId32 ")", mode, indirect, drawcount, stride);
    if (s->enter("glMultiDrawArraysIndirectEXT")) {
        s->glMultiDrawArraysIndirectEXT(mode, indirect, drawcount, stride);
        s->exit();
        GAPID_DEBUG("glMultiDrawArraysIndirectEXT() -- done");
    } else {
        GAPID_INFO("glMultiDrawArraysIndirectEXT at %p: GAPII re-entered. Just invoking imported function at %p", glMultiDrawArraysIndirectEXT, s->GlesSpy::imports().glMultiDrawArraysIndirectEXT);
        s->GlesSpy::imports().glMultiDrawArraysIndirectEXT(mode, indirect, drawcount, stride);
        GAPID_DEBUG("glMultiDrawArraysIndirectEXT() -- done");
    }
}
EXPORT void STDCALL glMultiDrawElementsBaseVertexEXT(uint32_t mode, GLsizei* count, uint32_t type, void** indices, GLsizei primcount, GLint* basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiDrawElementsBaseVertexEXT(%u, %p, %u, %p, %" PRId32 ", %p)", mode, count, type, indices, primcount, basevertex);
    if (s->enter("glMultiDrawElementsBaseVertexEXT")) {
        s->glMultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex);
        s->exit();
        GAPID_DEBUG("glMultiDrawElementsBaseVertexEXT() -- done");
    } else {
        GAPID_INFO("glMultiDrawElementsBaseVertexEXT at %p: GAPII re-entered. Just invoking imported function at %p", glMultiDrawElementsBaseVertexEXT, s->GlesSpy::imports().glMultiDrawElementsBaseVertexEXT);
        s->GlesSpy::imports().glMultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex);
        GAPID_DEBUG("glMultiDrawElementsBaseVertexEXT() -- done");
    }
}
EXPORT void STDCALL glMultiDrawElementsBaseVertexOES(uint32_t mode, GLsizei* count, uint32_t type, void** indices, GLsizei primcount, GLint* basevertex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiDrawElementsBaseVertexOES(%u, %p, %u, %p, %" PRId32 ", %p)", mode, count, type, indices, primcount, basevertex);
    if (s->enter("glMultiDrawElementsBaseVertexOES")) {
        s->glMultiDrawElementsBaseVertexOES(mode, count, type, indices, primcount, basevertex);
        s->exit();
        GAPID_DEBUG("glMultiDrawElementsBaseVertexOES() -- done");
    } else {
        GAPID_INFO("glMultiDrawElementsBaseVertexOES at %p: GAPII re-entered. Just invoking imported function at %p", glMultiDrawElementsBaseVertexOES, s->GlesSpy::imports().glMultiDrawElementsBaseVertexOES);
        s->GlesSpy::imports().glMultiDrawElementsBaseVertexOES(mode, count, type, indices, primcount, basevertex);
        GAPID_DEBUG("glMultiDrawElementsBaseVertexOES() -- done");
    }
}
EXPORT void STDCALL glMultiDrawElementsEXT(uint32_t mode, GLsizei* count, uint32_t type, void** indices, GLsizei primcount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiDrawElementsEXT(%u, %p, %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
    if (s->enter("glMultiDrawElementsEXT")) {
        s->glMultiDrawElementsEXT(mode, count, type, indices, primcount);
        s->exit();
        GAPID_DEBUG("glMultiDrawElementsEXT() -- done");
    } else {
        GAPID_INFO("glMultiDrawElementsEXT at %p: GAPII re-entered. Just invoking imported function at %p", glMultiDrawElementsEXT, s->GlesSpy::imports().glMultiDrawElementsEXT);
        s->GlesSpy::imports().glMultiDrawElementsEXT(mode, count, type, indices, primcount);
        GAPID_DEBUG("glMultiDrawElementsEXT() -- done");
    }
}
EXPORT void STDCALL glMultiDrawElementsIndirectEXT(uint32_t mode, uint32_t type, void* indirect, GLsizei drawcount, GLsizei stride) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiDrawElementsIndirectEXT(%u, %u, %p, %" PRId32 ", %" PRId32 ")", mode, type, indirect, drawcount, stride);
    if (s->enter("glMultiDrawElementsIndirectEXT")) {
        s->glMultiDrawElementsIndirectEXT(mode, type, indirect, drawcount, stride);
        s->exit();
        GAPID_DEBUG("glMultiDrawElementsIndirectEXT() -- done");
    } else {
        GAPID_INFO("glMultiDrawElementsIndirectEXT at %p: GAPII re-entered. Just invoking imported function at %p", glMultiDrawElementsIndirectEXT, s->GlesSpy::imports().glMultiDrawElementsIndirectEXT);
        s->GlesSpy::imports().glMultiDrawElementsIndirectEXT(mode, type, indirect, drawcount, stride);
        GAPID_DEBUG("glMultiDrawElementsIndirectEXT() -- done");
    }
}
EXPORT void STDCALL glNamedFramebufferSampleLocationsfvNV(FramebufferId framebuffer, GLuint start, GLsizei count, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glNamedFramebufferSampleLocationsfvNV(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p)", framebuffer, start, count, v);
    if (s->enter("glNamedFramebufferSampleLocationsfvNV")) {
        s->glNamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v);
        s->exit();
        GAPID_DEBUG("glNamedFramebufferSampleLocationsfvNV() -- done");
    } else {
        GAPID_INFO("glNamedFramebufferSampleLocationsfvNV at %p: GAPII re-entered. Just invoking imported function at %p", glNamedFramebufferSampleLocationsfvNV, s->GlesSpy::imports().glNamedFramebufferSampleLocationsfvNV);
        s->GlesSpy::imports().glNamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v);
        GAPID_DEBUG("glNamedFramebufferSampleLocationsfvNV() -- done");
    }
}
EXPORT void STDCALL glPatchParameteriOES(uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPatchParameteriOES(%u, %" PRId32 ")", pname, value);
    if (s->enter("glPatchParameteriOES")) {
        s->glPatchParameteriOES(pname, value);
        s->exit();
        GAPID_DEBUG("glPatchParameteriOES() -- done");
    } else {
        GAPID_INFO("glPatchParameteriOES at %p: GAPII re-entered. Just invoking imported function at %p", glPatchParameteriOES, s->GlesSpy::imports().glPatchParameteriOES);
        s->GlesSpy::imports().glPatchParameteriOES(pname, value);
        GAPID_DEBUG("glPatchParameteriOES() -- done");
    }
}
EXPORT void STDCALL glPathCommandsNV(GLuint path, GLsizei numCommands, GLubyte* commands, GLsizei numCoords, uint32_t coordType, void* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathCommandsNV(%" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %u, %p)", path, numCommands, commands, numCoords, coordType, coords);
    if (s->enter("glPathCommandsNV")) {
        s->glPathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
        s->exit();
        GAPID_DEBUG("glPathCommandsNV() -- done");
    } else {
        GAPID_INFO("glPathCommandsNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathCommandsNV, s->GlesSpy::imports().glPathCommandsNV);
        s->GlesSpy::imports().glPathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
        GAPID_DEBUG("glPathCommandsNV() -- done");
    }
}
EXPORT void STDCALL glPathCoordsNV(GLuint path, GLsizei numCoords, uint32_t coordType, void* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathCoordsNV(%" PRIu32 ", %" PRId32 ", %u, %p)", path, numCoords, coordType, coords);
    if (s->enter("glPathCoordsNV")) {
        s->glPathCoordsNV(path, numCoords, coordType, coords);
        s->exit();
        GAPID_DEBUG("glPathCoordsNV() -- done");
    } else {
        GAPID_INFO("glPathCoordsNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathCoordsNV, s->GlesSpy::imports().glPathCoordsNV);
        s->GlesSpy::imports().glPathCoordsNV(path, numCoords, coordType, coords);
        GAPID_DEBUG("glPathCoordsNV() -- done");
    }
}
EXPORT void STDCALL glPathCoverDepthFuncNV(uint32_t func) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathCoverDepthFuncNV(%u)", func);
    if (s->enter("glPathCoverDepthFuncNV")) {
        s->glPathCoverDepthFuncNV(func);
        s->exit();
        GAPID_DEBUG("glPathCoverDepthFuncNV() -- done");
    } else {
        GAPID_INFO("glPathCoverDepthFuncNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathCoverDepthFuncNV, s->GlesSpy::imports().glPathCoverDepthFuncNV);
        s->GlesSpy::imports().glPathCoverDepthFuncNV(func);
        GAPID_DEBUG("glPathCoverDepthFuncNV() -- done");
    }
}
EXPORT void STDCALL glPathDashArrayNV(GLuint path, GLsizei dashCount, GLfloat* dashArray) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathDashArrayNV(%" PRIu32 ", %" PRId32 ", %p)", path, dashCount, dashArray);
    if (s->enter("glPathDashArrayNV")) {
        s->glPathDashArrayNV(path, dashCount, dashArray);
        s->exit();
        GAPID_DEBUG("glPathDashArrayNV() -- done");
    } else {
        GAPID_INFO("glPathDashArrayNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathDashArrayNV, s->GlesSpy::imports().glPathDashArrayNV);
        s->GlesSpy::imports().glPathDashArrayNV(path, dashCount, dashArray);
        GAPID_DEBUG("glPathDashArrayNV() -- done");
    }
}
EXPORT uint32_t STDCALL glPathGlyphIndexArrayNV(GLuint firstPathName, uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathGlyphIndexArrayNV(%" PRIu32 ", %u, %p, %u, %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %f)", firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
    if (s->enter("glPathGlyphIndexArrayNV")) {
        auto _result_ = s->glPathGlyphIndexArrayNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
        s->exit();
        GAPID_DEBUG("glPathGlyphIndexArrayNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glPathGlyphIndexArrayNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathGlyphIndexArrayNV, s->GlesSpy::imports().glPathGlyphIndexArrayNV);
        auto _result_ = s->GlesSpy::imports().glPathGlyphIndexArrayNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
        GAPID_DEBUG("glPathGlyphIndexArrayNV() -- done");
        return _result_;
    }
}
EXPORT uint32_t STDCALL glPathGlyphIndexRangeNV(uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathGlyphIndexRangeNV(%u, %p, %u, %" PRIu32 ", %f, %" PRIu32 ")", fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
    if (s->enter("glPathGlyphIndexRangeNV")) {
        auto _result_ = s->glPathGlyphIndexRangeNV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
        s->exit();
        GAPID_DEBUG("glPathGlyphIndexRangeNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glPathGlyphIndexRangeNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathGlyphIndexRangeNV, s->GlesSpy::imports().glPathGlyphIndexRangeNV);
        auto _result_ = s->GlesSpy::imports().glPathGlyphIndexRangeNV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
        GAPID_DEBUG("glPathGlyphIndexRangeNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glPathGlyphRangeNV(GLuint firstPathName, uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLuint firstGlyph, GLsizei numGlyphs, uint32_t handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathGlyphRangeNV(%" PRIu32 ", %u, %p, %u, %" PRIu32 ", %" PRId32 ", %u, %" PRIu32 ", %f)", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
    if (s->enter("glPathGlyphRangeNV")) {
        s->glPathGlyphRangeNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
        s->exit();
        GAPID_DEBUG("glPathGlyphRangeNV() -- done");
    } else {
        GAPID_INFO("glPathGlyphRangeNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathGlyphRangeNV, s->GlesSpy::imports().glPathGlyphRangeNV);
        s->GlesSpy::imports().glPathGlyphRangeNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
        GAPID_DEBUG("glPathGlyphRangeNV() -- done");
    }
}
EXPORT void STDCALL glPathGlyphsNV(GLuint firstPathName, uint32_t fontTarget, void* fontName, uint32_t fontStyle, GLsizei numGlyphs, uint32_t type, void* charcodes, uint32_t handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathGlyphsNV(%" PRIu32 ", %u, %p, %u, %" PRId32 ", %u, %p, %u, %" PRIu32 ", %f)", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
    if (s->enter("glPathGlyphsNV")) {
        s->glPathGlyphsNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
        s->exit();
        GAPID_DEBUG("glPathGlyphsNV() -- done");
    } else {
        GAPID_INFO("glPathGlyphsNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathGlyphsNV, s->GlesSpy::imports().glPathGlyphsNV);
        s->GlesSpy::imports().glPathGlyphsNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
        GAPID_DEBUG("glPathGlyphsNV() -- done");
    }
}
EXPORT uint32_t STDCALL glPathMemoryGlyphIndexArrayNV(GLuint firstPathName, uint32_t fontTarget, GLsizeiptr fontSize, void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathMemoryGlyphIndexArrayNV(%" PRIu32 ", %u, %" PRId32 ", %p, %" PRId32 ", %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %f)", firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
    if (s->enter("glPathMemoryGlyphIndexArrayNV")) {
        auto _result_ = s->glPathMemoryGlyphIndexArrayNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
        s->exit();
        GAPID_DEBUG("glPathMemoryGlyphIndexArrayNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glPathMemoryGlyphIndexArrayNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathMemoryGlyphIndexArrayNV, s->GlesSpy::imports().glPathMemoryGlyphIndexArrayNV);
        auto _result_ = s->GlesSpy::imports().glPathMemoryGlyphIndexArrayNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
        GAPID_DEBUG("glPathMemoryGlyphIndexArrayNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glPathParameterfNV(GLuint path, uint32_t pname, GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathParameterfNV(%" PRIu32 ", %u, %f)", path, pname, value);
    if (s->enter("glPathParameterfNV")) {
        s->glPathParameterfNV(path, pname, value);
        s->exit();
        GAPID_DEBUG("glPathParameterfNV() -- done");
    } else {
        GAPID_INFO("glPathParameterfNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathParameterfNV, s->GlesSpy::imports().glPathParameterfNV);
        s->GlesSpy::imports().glPathParameterfNV(path, pname, value);
        GAPID_DEBUG("glPathParameterfNV() -- done");
    }
}
EXPORT void STDCALL glPathParameterfvNV(GLuint path, uint32_t pname, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathParameterfvNV(%" PRIu32 ", %u, %p)", path, pname, value);
    if (s->enter("glPathParameterfvNV")) {
        s->glPathParameterfvNV(path, pname, value);
        s->exit();
        GAPID_DEBUG("glPathParameterfvNV() -- done");
    } else {
        GAPID_INFO("glPathParameterfvNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathParameterfvNV, s->GlesSpy::imports().glPathParameterfvNV);
        s->GlesSpy::imports().glPathParameterfvNV(path, pname, value);
        GAPID_DEBUG("glPathParameterfvNV() -- done");
    }
}
EXPORT void STDCALL glPathParameteriNV(GLuint path, uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathParameteriNV(%" PRIu32 ", %u, %" PRId32 ")", path, pname, value);
    if (s->enter("glPathParameteriNV")) {
        s->glPathParameteriNV(path, pname, value);
        s->exit();
        GAPID_DEBUG("glPathParameteriNV() -- done");
    } else {
        GAPID_INFO("glPathParameteriNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathParameteriNV, s->GlesSpy::imports().glPathParameteriNV);
        s->GlesSpy::imports().glPathParameteriNV(path, pname, value);
        GAPID_DEBUG("glPathParameteriNV() -- done");
    }
}
EXPORT void STDCALL glPathParameterivNV(GLuint path, uint32_t pname, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathParameterivNV(%" PRIu32 ", %u, %p)", path, pname, value);
    if (s->enter("glPathParameterivNV")) {
        s->glPathParameterivNV(path, pname, value);
        s->exit();
        GAPID_DEBUG("glPathParameterivNV() -- done");
    } else {
        GAPID_INFO("glPathParameterivNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathParameterivNV, s->GlesSpy::imports().glPathParameterivNV);
        s->GlesSpy::imports().glPathParameterivNV(path, pname, value);
        GAPID_DEBUG("glPathParameterivNV() -- done");
    }
}
EXPORT void STDCALL glPathStencilDepthOffsetNV(GLfloat factor, GLfloat units) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathStencilDepthOffsetNV(%f, %f)", factor, units);
    if (s->enter("glPathStencilDepthOffsetNV")) {
        s->glPathStencilDepthOffsetNV(factor, units);
        s->exit();
        GAPID_DEBUG("glPathStencilDepthOffsetNV() -- done");
    } else {
        GAPID_INFO("glPathStencilDepthOffsetNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathStencilDepthOffsetNV, s->GlesSpy::imports().glPathStencilDepthOffsetNV);
        s->GlesSpy::imports().glPathStencilDepthOffsetNV(factor, units);
        GAPID_DEBUG("glPathStencilDepthOffsetNV() -- done");
    }
}
EXPORT void STDCALL glPathStencilFuncNV(uint32_t func, GLint ref, GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathStencilFuncNV(%u, %" PRId32 ", %" PRIu32 ")", func, ref, mask);
    if (s->enter("glPathStencilFuncNV")) {
        s->glPathStencilFuncNV(func, ref, mask);
        s->exit();
        GAPID_DEBUG("glPathStencilFuncNV() -- done");
    } else {
        GAPID_INFO("glPathStencilFuncNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathStencilFuncNV, s->GlesSpy::imports().glPathStencilFuncNV);
        s->GlesSpy::imports().glPathStencilFuncNV(func, ref, mask);
        GAPID_DEBUG("glPathStencilFuncNV() -- done");
    }
}
EXPORT void STDCALL glPathStringNV(GLuint path, uint32_t format, GLsizei length, void* pathString) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathStringNV(%" PRIu32 ", %u, %" PRId32 ", %p)", path, format, length, pathString);
    if (s->enter("glPathStringNV")) {
        s->glPathStringNV(path, format, length, pathString);
        s->exit();
        GAPID_DEBUG("glPathStringNV() -- done");
    } else {
        GAPID_INFO("glPathStringNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathStringNV, s->GlesSpy::imports().glPathStringNV);
        s->GlesSpy::imports().glPathStringNV(path, format, length, pathString);
        GAPID_DEBUG("glPathStringNV() -- done");
    }
}
EXPORT void STDCALL glPathSubCommandsNV(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, GLubyte* commands, GLsizei numCoords, uint32_t coordType, void* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathSubCommandsNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p, %" PRId32 ", %u, %p)", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
    if (s->enter("glPathSubCommandsNV")) {
        s->glPathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
        s->exit();
        GAPID_DEBUG("glPathSubCommandsNV() -- done");
    } else {
        GAPID_INFO("glPathSubCommandsNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathSubCommandsNV, s->GlesSpy::imports().glPathSubCommandsNV);
        s->GlesSpy::imports().glPathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
        GAPID_DEBUG("glPathSubCommandsNV() -- done");
    }
}
EXPORT void STDCALL glPathSubCoordsNV(GLuint path, GLsizei coordStart, GLsizei numCoords, uint32_t coordType, void* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathSubCoordsNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %u, %p)", path, coordStart, numCoords, coordType, coords);
    if (s->enter("glPathSubCoordsNV")) {
        s->glPathSubCoordsNV(path, coordStart, numCoords, coordType, coords);
        s->exit();
        GAPID_DEBUG("glPathSubCoordsNV() -- done");
    } else {
        GAPID_INFO("glPathSubCoordsNV at %p: GAPII re-entered. Just invoking imported function at %p", glPathSubCoordsNV, s->GlesSpy::imports().glPathSubCoordsNV);
        s->GlesSpy::imports().glPathSubCoordsNV(path, coordStart, numCoords, coordType, coords);
        GAPID_DEBUG("glPathSubCoordsNV() -- done");
    }
}
EXPORT GLboolean STDCALL glPointAlongPathNV(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointAlongPathNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %f, %p, %p, %p, %p)", path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
    if (s->enter("glPointAlongPathNV")) {
        auto _result_ = s->glPointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
        s->exit();
        GAPID_DEBUG("glPointAlongPathNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glPointAlongPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glPointAlongPathNV, s->GlesSpy::imports().glPointAlongPathNV);
        auto _result_ = s->GlesSpy::imports().glPointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
        GAPID_DEBUG("glPointAlongPathNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glPolygonModeNV(uint32_t face, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPolygonModeNV(%u, %u)", face, mode);
    if (s->enter("glPolygonModeNV")) {
        s->glPolygonModeNV(face, mode);
        s->exit();
        GAPID_DEBUG("glPolygonModeNV() -- done");
    } else {
        GAPID_INFO("glPolygonModeNV at %p: GAPII re-entered. Just invoking imported function at %p", glPolygonModeNV, s->GlesSpy::imports().glPolygonModeNV);
        s->GlesSpy::imports().glPolygonModeNV(face, mode);
        GAPID_DEBUG("glPolygonModeNV() -- done");
    }
}
EXPORT void STDCALL glPopGroupMarkerEXT() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopGroupMarkerEXT()");
    if (s->enter("glPopGroupMarkerEXT")) {
        s->glPopGroupMarkerEXT();
        s->exit();
        GAPID_DEBUG("glPopGroupMarkerEXT() -- done");
    } else {
        GAPID_INFO("glPopGroupMarkerEXT at %p: GAPII re-entered. Just invoking imported function at %p", glPopGroupMarkerEXT, s->GlesSpy::imports().glPopGroupMarkerEXT);
        s->GlesSpy::imports().glPopGroupMarkerEXT();
        GAPID_DEBUG("glPopGroupMarkerEXT() -- done");
    }
}
EXPORT void STDCALL glPrimitiveBoundingBoxOES(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPrimitiveBoundingBoxOES(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
    if (s->enter("glPrimitiveBoundingBoxOES")) {
        s->glPrimitiveBoundingBoxOES(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
        s->exit();
        GAPID_DEBUG("glPrimitiveBoundingBoxOES() -- done");
    } else {
        GAPID_INFO("glPrimitiveBoundingBoxOES at %p: GAPII re-entered. Just invoking imported function at %p", glPrimitiveBoundingBoxOES, s->GlesSpy::imports().glPrimitiveBoundingBoxOES);
        s->GlesSpy::imports().glPrimitiveBoundingBoxOES(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
        GAPID_DEBUG("glPrimitiveBoundingBoxOES() -- done");
    }
}
EXPORT void STDCALL glProgramBinaryOES(ProgramId program, uint32_t binary_format, void* binary, GLint binary_size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramBinaryOES(%" PRIu32 ", %u, %p, %" PRId32 ")", program, binary_format, binary, binary_size);
    if (s->enter("glProgramBinaryOES")) {
        s->glProgramBinaryOES(program, binary_format, binary, binary_size);
        s->exit();
        GAPID_DEBUG("glProgramBinaryOES() -- done");
    } else {
        GAPID_INFO("glProgramBinaryOES at %p: GAPII re-entered. Just invoking imported function at %p", glProgramBinaryOES, s->GlesSpy::imports().glProgramBinaryOES);
        s->GlesSpy::imports().glProgramBinaryOES(program, binary_format, binary, binary_size);
        GAPID_DEBUG("glProgramBinaryOES() -- done");
    }
}
EXPORT void STDCALL glProgramParameteriEXT(ProgramId program, uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramParameteriEXT(%" PRIu32 ", %u, %" PRId32 ")", program, pname, value);
    if (s->enter("glProgramParameteriEXT")) {
        s->glProgramParameteriEXT(program, pname, value);
        s->exit();
        GAPID_DEBUG("glProgramParameteriEXT() -- done");
    } else {
        GAPID_INFO("glProgramParameteriEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramParameteriEXT, s->GlesSpy::imports().glProgramParameteriEXT);
        s->GlesSpy::imports().glProgramParameteriEXT(program, pname, value);
        GAPID_DEBUG("glProgramParameteriEXT() -- done");
    }
}
EXPORT void STDCALL glProgramPathFragmentInputGenNV(ProgramId program, GLint location, uint32_t genMode, GLint components, GLfloat* coeffs) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramPathFragmentInputGenNV(%" PRIu32 ", %" PRId32 ", %u, %" PRId32 ", %p)", program, location, genMode, components, coeffs);
    if (s->enter("glProgramPathFragmentInputGenNV")) {
        s->glProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs);
        s->exit();
        GAPID_DEBUG("glProgramPathFragmentInputGenNV() -- done");
    } else {
        GAPID_INFO("glProgramPathFragmentInputGenNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramPathFragmentInputGenNV, s->GlesSpy::imports().glProgramPathFragmentInputGenNV);
        s->GlesSpy::imports().glProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs);
        GAPID_DEBUG("glProgramPathFragmentInputGenNV() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1fEXT(ProgramId program, UniformLocation location, GLfloat v0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1fEXT(%" PRIu32 ", %" PRId32 ", %f)", program, location, v0);
    if (s->enter("glProgramUniform1fEXT")) {
        s->glProgramUniform1fEXT(program, location, v0);
        s->exit();
        GAPID_DEBUG("glProgramUniform1fEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform1fEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1fEXT, s->GlesSpy::imports().glProgramUniform1fEXT);
        s->GlesSpy::imports().glProgramUniform1fEXT(program, location, v0);
        GAPID_DEBUG("glProgramUniform1fEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform1fvEXT")) {
        s->glProgramUniform1fvEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform1fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform1fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1fvEXT, s->GlesSpy::imports().glProgramUniform1fvEXT);
        s->GlesSpy::imports().glProgramUniform1fvEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform1fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1iEXT(ProgramId program, UniformLocation location, GLint v0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ")", program, location, v0);
    if (s->enter("glProgramUniform1iEXT")) {
        s->glProgramUniform1iEXT(program, location, v0);
        s->exit();
        GAPID_DEBUG("glProgramUniform1iEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform1iEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1iEXT, s->GlesSpy::imports().glProgramUniform1iEXT);
        s->GlesSpy::imports().glProgramUniform1iEXT(program, location, v0);
        GAPID_DEBUG("glProgramUniform1iEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform1ivEXT")) {
        s->glProgramUniform1ivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform1ivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform1ivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1ivEXT, s->GlesSpy::imports().glProgramUniform1ivEXT);
        s->GlesSpy::imports().glProgramUniform1ivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform1ivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1uiEXT(ProgramId program, UniformLocation location, GLuint v0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")", program, location, v0);
    if (s->enter("glProgramUniform1uiEXT")) {
        s->glProgramUniform1uiEXT(program, location, v0);
        s->exit();
        GAPID_DEBUG("glProgramUniform1uiEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform1uiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1uiEXT, s->GlesSpy::imports().glProgramUniform1uiEXT);
        s->GlesSpy::imports().glProgramUniform1uiEXT(program, location, v0);
        GAPID_DEBUG("glProgramUniform1uiEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform1uivEXT")) {
        s->glProgramUniform1uivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform1uivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform1uivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1uivEXT, s->GlesSpy::imports().glProgramUniform1uivEXT);
        s->GlesSpy::imports().glProgramUniform1uivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform1uivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2fEXT(ProgramId program, UniformLocation location, GLfloat v0, GLfloat v1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2fEXT(%" PRIu32 ", %" PRId32 ", %f, %f)", program, location, v0, v1);
    if (s->enter("glProgramUniform2fEXT")) {
        s->glProgramUniform2fEXT(program, location, v0, v1);
        s->exit();
        GAPID_DEBUG("glProgramUniform2fEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform2fEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2fEXT, s->GlesSpy::imports().glProgramUniform2fEXT);
        s->GlesSpy::imports().glProgramUniform2fEXT(program, location, v0, v1);
        GAPID_DEBUG("glProgramUniform2fEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform2fvEXT")) {
        s->glProgramUniform2fvEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform2fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform2fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2fvEXT, s->GlesSpy::imports().glProgramUniform2fvEXT);
        s->GlesSpy::imports().glProgramUniform2fvEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform2fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2iEXT(ProgramId program, UniformLocation location, GLint v0, GLint v1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, v0, v1);
    if (s->enter("glProgramUniform2iEXT")) {
        s->glProgramUniform2iEXT(program, location, v0, v1);
        s->exit();
        GAPID_DEBUG("glProgramUniform2iEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform2iEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2iEXT, s->GlesSpy::imports().glProgramUniform2iEXT);
        s->GlesSpy::imports().glProgramUniform2iEXT(program, location, v0, v1);
        GAPID_DEBUG("glProgramUniform2iEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform2ivEXT")) {
        s->glProgramUniform2ivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform2ivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform2ivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2ivEXT, s->GlesSpy::imports().glProgramUniform2ivEXT);
        s->GlesSpy::imports().glProgramUniform2ivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform2ivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2uiEXT(ProgramId program, UniformLocation location, GLuint v0, GLuint v1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ")", program, location, v0, v1);
    if (s->enter("glProgramUniform2uiEXT")) {
        s->glProgramUniform2uiEXT(program, location, v0, v1);
        s->exit();
        GAPID_DEBUG("glProgramUniform2uiEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform2uiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2uiEXT, s->GlesSpy::imports().glProgramUniform2uiEXT);
        s->GlesSpy::imports().glProgramUniform2uiEXT(program, location, v0, v1);
        GAPID_DEBUG("glProgramUniform2uiEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform2uivEXT")) {
        s->glProgramUniform2uivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform2uivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform2uivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2uivEXT, s->GlesSpy::imports().glProgramUniform2uivEXT);
        s->GlesSpy::imports().glProgramUniform2uivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform2uivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3fEXT(ProgramId program, UniformLocation location, GLfloat v0, GLfloat v1, GLfloat v2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3fEXT(%" PRIu32 ", %" PRId32 ", %f, %f, %f)", program, location, v0, v1, v2);
    if (s->enter("glProgramUniform3fEXT")) {
        s->glProgramUniform3fEXT(program, location, v0, v1, v2);
        s->exit();
        GAPID_DEBUG("glProgramUniform3fEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform3fEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3fEXT, s->GlesSpy::imports().glProgramUniform3fEXT);
        s->GlesSpy::imports().glProgramUniform3fEXT(program, location, v0, v1, v2);
        GAPID_DEBUG("glProgramUniform3fEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform3fvEXT")) {
        s->glProgramUniform3fvEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform3fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform3fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3fvEXT, s->GlesSpy::imports().glProgramUniform3fvEXT);
        s->GlesSpy::imports().glProgramUniform3fvEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform3fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3iEXT(ProgramId program, UniformLocation location, GLint v0, GLint v1, GLint v2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, v0, v1, v2);
    if (s->enter("glProgramUniform3iEXT")) {
        s->glProgramUniform3iEXT(program, location, v0, v1, v2);
        s->exit();
        GAPID_DEBUG("glProgramUniform3iEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform3iEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3iEXT, s->GlesSpy::imports().glProgramUniform3iEXT);
        s->GlesSpy::imports().glProgramUniform3iEXT(program, location, v0, v1, v2);
        GAPID_DEBUG("glProgramUniform3iEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform3ivEXT")) {
        s->glProgramUniform3ivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform3ivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform3ivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3ivEXT, s->GlesSpy::imports().glProgramUniform3ivEXT);
        s->GlesSpy::imports().glProgramUniform3ivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform3ivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3uiEXT(ProgramId program, UniformLocation location, GLuint v0, GLuint v1, GLuint v2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, v0, v1, v2);
    if (s->enter("glProgramUniform3uiEXT")) {
        s->glProgramUniform3uiEXT(program, location, v0, v1, v2);
        s->exit();
        GAPID_DEBUG("glProgramUniform3uiEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform3uiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3uiEXT, s->GlesSpy::imports().glProgramUniform3uiEXT);
        s->GlesSpy::imports().glProgramUniform3uiEXT(program, location, v0, v1, v2);
        GAPID_DEBUG("glProgramUniform3uiEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform3uivEXT")) {
        s->glProgramUniform3uivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform3uivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform3uivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3uivEXT, s->GlesSpy::imports().glProgramUniform3uivEXT);
        s->GlesSpy::imports().glProgramUniform3uivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform3uivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4fEXT(ProgramId program, UniformLocation location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4fEXT(%" PRIu32 ", %" PRId32 ", %f, %f, %f, %f)", program, location, v0, v1, v2, v3);
    if (s->enter("glProgramUniform4fEXT")) {
        s->glProgramUniform4fEXT(program, location, v0, v1, v2, v3);
        s->exit();
        GAPID_DEBUG("glProgramUniform4fEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform4fEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4fEXT, s->GlesSpy::imports().glProgramUniform4fEXT);
        s->GlesSpy::imports().glProgramUniform4fEXT(program, location, v0, v1, v2, v3);
        GAPID_DEBUG("glProgramUniform4fEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform4fvEXT")) {
        s->glProgramUniform4fvEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform4fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform4fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4fvEXT, s->GlesSpy::imports().glProgramUniform4fvEXT);
        s->GlesSpy::imports().glProgramUniform4fvEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform4fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4iEXT(ProgramId program, UniformLocation location, GLint v0, GLint v1, GLint v2, GLint v3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, v0, v1, v2, v3);
    if (s->enter("glProgramUniform4iEXT")) {
        s->glProgramUniform4iEXT(program, location, v0, v1, v2, v3);
        s->exit();
        GAPID_DEBUG("glProgramUniform4iEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform4iEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4iEXT, s->GlesSpy::imports().glProgramUniform4iEXT);
        s->GlesSpy::imports().glProgramUniform4iEXT(program, location, v0, v1, v2, v3);
        GAPID_DEBUG("glProgramUniform4iEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4ivEXT(ProgramId program, UniformLocation location, GLsizei count, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform4ivEXT")) {
        s->glProgramUniform4ivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform4ivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform4ivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4ivEXT, s->GlesSpy::imports().glProgramUniform4ivEXT);
        s->GlesSpy::imports().glProgramUniform4ivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform4ivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4uiEXT(ProgramId program, UniformLocation location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, v0, v1, v2, v3);
    if (s->enter("glProgramUniform4uiEXT")) {
        s->glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
        s->exit();
        GAPID_DEBUG("glProgramUniform4uiEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform4uiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4uiEXT, s->GlesSpy::imports().glProgramUniform4uiEXT);
        s->GlesSpy::imports().glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
        GAPID_DEBUG("glProgramUniform4uiEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4uivEXT(ProgramId program, UniformLocation location, GLsizei count, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (s->enter("glProgramUniform4uivEXT")) {
        s->glProgramUniform4uivEXT(program, location, count, value);
        s->exit();
        GAPID_DEBUG("glProgramUniform4uivEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniform4uivEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4uivEXT, s->GlesSpy::imports().glProgramUniform4uivEXT);
        s->GlesSpy::imports().glProgramUniform4uivEXT(program, location, count, value);
        GAPID_DEBUG("glProgramUniform4uivEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformHandleui64NV(ProgramId program, UniformLocation location, GLuint64 value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformHandleui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ")", program, location, value);
    if (s->enter("glProgramUniformHandleui64NV")) {
        s->glProgramUniformHandleui64NV(program, location, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformHandleui64NV() -- done");
    } else {
        GAPID_INFO("glProgramUniformHandleui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformHandleui64NV, s->GlesSpy::imports().glProgramUniformHandleui64NV);
        s->GlesSpy::imports().glProgramUniformHandleui64NV(program, location, value);
        GAPID_DEBUG("glProgramUniformHandleui64NV() -- done");
    }
}
EXPORT void STDCALL glProgramUniformHandleui64vNV(ProgramId program, UniformLocation location, GLsizei count, GLuint64* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformHandleui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniformHandleui64vNV")) {
        s->glProgramUniformHandleui64vNV(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformHandleui64vNV() -- done");
    } else {
        GAPID_INFO("glProgramUniformHandleui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformHandleui64vNV, s->GlesSpy::imports().glProgramUniformHandleui64vNV);
        s->GlesSpy::imports().glProgramUniformHandleui64vNV(program, location, count, values);
        GAPID_DEBUG("glProgramUniformHandleui64vNV() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix2fvEXT")) {
        s->glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix2fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix2fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix2fvEXT, s->GlesSpy::imports().glProgramUniformMatrix2fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix2fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix2x3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix2x3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix2x3fvEXT")) {
        s->glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix2x3fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix2x3fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix2x3fvEXT, s->GlesSpy::imports().glProgramUniformMatrix2x3fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix2x3fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix2x4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix2x4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix2x4fvEXT")) {
        s->glProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix2x4fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix2x4fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix2x4fvEXT, s->GlesSpy::imports().glProgramUniformMatrix2x4fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix2x4fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix3fvEXT")) {
        s->glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix3fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix3fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix3fvEXT, s->GlesSpy::imports().glProgramUniformMatrix3fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix3fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix3x2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix3x2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix3x2fvEXT")) {
        s->glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix3x2fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix3x2fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix3x2fvEXT, s->GlesSpy::imports().glProgramUniformMatrix3x2fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix3x2fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix3x4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix3x4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix3x4fvEXT")) {
        s->glProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix3x4fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix3x4fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix3x4fvEXT, s->GlesSpy::imports().glProgramUniformMatrix3x4fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix3x4fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix4fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix4fvEXT")) {
        s->glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix4fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix4fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix4fvEXT, s->GlesSpy::imports().glProgramUniformMatrix4fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix4fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix4x2fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix4x2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix4x2fvEXT")) {
        s->glProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix4x2fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix4x2fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix4x2fvEXT, s->GlesSpy::imports().glProgramUniformMatrix4x2fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix4x2fvEXT() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix4x3fvEXT(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix4x3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
    if (s->enter("glProgramUniformMatrix4x3fvEXT")) {
        s->glProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix4x3fvEXT() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix4x3fvEXT at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix4x3fvEXT, s->GlesSpy::imports().glProgramUniformMatrix4x3fvEXT);
        s->GlesSpy::imports().glProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);
        GAPID_DEBUG("glProgramUniformMatrix4x3fvEXT() -- done");
    }
}
EXPORT void STDCALL glPushGroupMarkerEXT(GLsizei length, GLchar* marker) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPushGroupMarkerEXT(%" PRId32 ", %p)", length, marker);
    if (s->enter("glPushGroupMarkerEXT")) {
        s->glPushGroupMarkerEXT(length, marker);
        s->exit();
        GAPID_DEBUG("glPushGroupMarkerEXT() -- done");
    } else {
        GAPID_INFO("glPushGroupMarkerEXT at %p: GAPII re-entered. Just invoking imported function at %p", glPushGroupMarkerEXT, s->GlesSpy::imports().glPushGroupMarkerEXT);
        s->GlesSpy::imports().glPushGroupMarkerEXT(length, marker);
        GAPID_DEBUG("glPushGroupMarkerEXT() -- done");
    }
}
EXPORT void STDCALL glQueryCounterEXT(QueryId query, uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glQueryCounterEXT(%" PRIu32 ", %u)", query, target);
    if (s->enter("glQueryCounterEXT")) {
        s->glQueryCounterEXT(query, target);
        s->exit();
        GAPID_DEBUG("glQueryCounterEXT() -- done");
    } else {
        GAPID_INFO("glQueryCounterEXT at %p: GAPII re-entered. Just invoking imported function at %p", glQueryCounterEXT, s->GlesSpy::imports().glQueryCounterEXT);
        s->GlesSpy::imports().glQueryCounterEXT(query, target);
        GAPID_DEBUG("glQueryCounterEXT() -- done");
    }
}
EXPORT void STDCALL glRasterSamplesEXT(GLuint samples, GLboolean fixedsamplelocations) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRasterSamplesEXT(%" PRIu32 ", %" PRIu8 ")", samples, fixedsamplelocations);
    if (s->enter("glRasterSamplesEXT")) {
        s->glRasterSamplesEXT(samples, fixedsamplelocations);
        s->exit();
        GAPID_DEBUG("glRasterSamplesEXT() -- done");
    } else {
        GAPID_INFO("glRasterSamplesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glRasterSamplesEXT, s->GlesSpy::imports().glRasterSamplesEXT);
        s->GlesSpy::imports().glRasterSamplesEXT(samples, fixedsamplelocations);
        GAPID_DEBUG("glRasterSamplesEXT() -- done");
    }
}
EXPORT void STDCALL glReadBufferIndexedEXT(uint32_t src, GLint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadBufferIndexedEXT(%u, %" PRId32 ")", src, index);
    if (s->enter("glReadBufferIndexedEXT")) {
        s->glReadBufferIndexedEXT(src, index);
        s->exit();
        GAPID_DEBUG("glReadBufferIndexedEXT() -- done");
    } else {
        GAPID_INFO("glReadBufferIndexedEXT at %p: GAPII re-entered. Just invoking imported function at %p", glReadBufferIndexedEXT, s->GlesSpy::imports().glReadBufferIndexedEXT);
        s->GlesSpy::imports().glReadBufferIndexedEXT(src, index);
        GAPID_DEBUG("glReadBufferIndexedEXT() -- done");
    }
}
EXPORT void STDCALL glReadBufferNV(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadBufferNV(%u)", mode);
    if (s->enter("glReadBufferNV")) {
        s->glReadBufferNV(mode);
        s->exit();
        GAPID_DEBUG("glReadBufferNV() -- done");
    } else {
        GAPID_INFO("glReadBufferNV at %p: GAPII re-entered. Just invoking imported function at %p", glReadBufferNV, s->GlesSpy::imports().glReadBufferNV);
        s->GlesSpy::imports().glReadBufferNV(mode);
        GAPID_DEBUG("glReadBufferNV() -- done");
    }
}
EXPORT void STDCALL glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, GLsizei bufSize, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadnPixelsEXT(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %" PRId32 ", %p)", x, y, width, height, format, type, bufSize, data);
    if (s->enter("glReadnPixelsEXT")) {
        s->glReadnPixelsEXT(x, y, width, height, format, type, bufSize, data);
        s->exit();
        GAPID_DEBUG("glReadnPixelsEXT() -- done");
    } else {
        GAPID_INFO("glReadnPixelsEXT at %p: GAPII re-entered. Just invoking imported function at %p", glReadnPixelsEXT, s->GlesSpy::imports().glReadnPixelsEXT);
        s->GlesSpy::imports().glReadnPixelsEXT(x, y, width, height, format, type, bufSize, data);
        GAPID_DEBUG("glReadnPixelsEXT() -- done");
    }
}
EXPORT void STDCALL glReadnPixelsKHR(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, GLsizei bufSize, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadnPixelsKHR(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %" PRId32 ", %p)", x, y, width, height, format, type, bufSize, data);
    if (s->enter("glReadnPixelsKHR")) {
        s->glReadnPixelsKHR(x, y, width, height, format, type, bufSize, data);
        s->exit();
        GAPID_DEBUG("glReadnPixelsKHR() -- done");
    } else {
        GAPID_INFO("glReadnPixelsKHR at %p: GAPII re-entered. Just invoking imported function at %p", glReadnPixelsKHR, s->GlesSpy::imports().glReadnPixelsKHR);
        s->GlesSpy::imports().glReadnPixelsKHR(x, y, width, height, format, type, bufSize, data);
        GAPID_DEBUG("glReadnPixelsKHR() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorageMultisampleANGLE(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageMultisampleANGLE(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
    if (s->enter("glRenderbufferStorageMultisampleANGLE")) {
        s->glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageMultisampleANGLE() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageMultisampleANGLE at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageMultisampleANGLE, s->GlesSpy::imports().glRenderbufferStorageMultisampleANGLE);
        s->GlesSpy::imports().glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageMultisampleANGLE() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorageMultisampleAPPLE(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageMultisampleAPPLE(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
    if (s->enter("glRenderbufferStorageMultisampleAPPLE")) {
        s->glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageMultisampleAPPLE() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageMultisampleAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageMultisampleAPPLE, s->GlesSpy::imports().glRenderbufferStorageMultisampleAPPLE);
        s->GlesSpy::imports().glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageMultisampleAPPLE() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorageMultisampleEXT(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageMultisampleEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
    if (s->enter("glRenderbufferStorageMultisampleEXT")) {
        s->glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageMultisampleEXT() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageMultisampleEXT at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageMultisampleEXT, s->GlesSpy::imports().glRenderbufferStorageMultisampleEXT);
        s->GlesSpy::imports().glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageMultisampleEXT() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorageMultisampleIMG(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageMultisampleIMG(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
    if (s->enter("glRenderbufferStorageMultisampleIMG")) {
        s->glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageMultisampleIMG() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageMultisampleIMG at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageMultisampleIMG, s->GlesSpy::imports().glRenderbufferStorageMultisampleIMG);
        s->GlesSpy::imports().glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageMultisampleIMG() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorageMultisampleNV(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageMultisampleNV(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
    if (s->enter("glRenderbufferStorageMultisampleNV")) {
        s->glRenderbufferStorageMultisampleNV(target, samples, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageMultisampleNV() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageMultisampleNV at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageMultisampleNV, s->GlesSpy::imports().glRenderbufferStorageMultisampleNV);
        s->GlesSpy::imports().glRenderbufferStorageMultisampleNV(target, samples, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageMultisampleNV() -- done");
    }
}
EXPORT void STDCALL glResolveDepthValuesNV() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glResolveDepthValuesNV()");
    if (s->enter("glResolveDepthValuesNV")) {
        s->glResolveDepthValuesNV();
        s->exit();
        GAPID_DEBUG("glResolveDepthValuesNV() -- done");
    } else {
        GAPID_INFO("glResolveDepthValuesNV at %p: GAPII re-entered. Just invoking imported function at %p", glResolveDepthValuesNV, s->GlesSpy::imports().glResolveDepthValuesNV);
        s->GlesSpy::imports().glResolveDepthValuesNV();
        GAPID_DEBUG("glResolveDepthValuesNV() -- done");
    }
}
EXPORT void STDCALL glResolveMultisampleFramebufferAPPLE() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glResolveMultisampleFramebufferAPPLE()");
    if (s->enter("glResolveMultisampleFramebufferAPPLE")) {
        s->glResolveMultisampleFramebufferAPPLE();
        s->exit();
        GAPID_DEBUG("glResolveMultisampleFramebufferAPPLE() -- done");
    } else {
        GAPID_INFO("glResolveMultisampleFramebufferAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glResolveMultisampleFramebufferAPPLE, s->GlesSpy::imports().glResolveMultisampleFramebufferAPPLE);
        s->GlesSpy::imports().glResolveMultisampleFramebufferAPPLE();
        GAPID_DEBUG("glResolveMultisampleFramebufferAPPLE() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterIivOES(SamplerId sampler, uint32_t pname, GLint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterIivOES(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterIivOES")) {
        s->glSamplerParameterIivOES(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterIivOES() -- done");
    } else {
        GAPID_INFO("glSamplerParameterIivOES at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterIivOES, s->GlesSpy::imports().glSamplerParameterIivOES);
        s->GlesSpy::imports().glSamplerParameterIivOES(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterIivOES() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterIuivOES(SamplerId sampler, uint32_t pname, GLuint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterIuivOES(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterIuivOES")) {
        s->glSamplerParameterIuivOES(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterIuivOES() -- done");
    } else {
        GAPID_INFO("glSamplerParameterIuivOES at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterIuivOES, s->GlesSpy::imports().glSamplerParameterIuivOES);
        s->GlesSpy::imports().glSamplerParameterIuivOES(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterIuivOES() -- done");
    }
}
EXPORT void STDCALL glScissorArrayvNV(GLuint first, GLsizei count, GLint* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissorArrayvNV(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
    if (s->enter("glScissorArrayvNV")) {
        s->glScissorArrayvNV(first, count, v);
        s->exit();
        GAPID_DEBUG("glScissorArrayvNV() -- done");
    } else {
        GAPID_INFO("glScissorArrayvNV at %p: GAPII re-entered. Just invoking imported function at %p", glScissorArrayvNV, s->GlesSpy::imports().glScissorArrayvNV);
        s->GlesSpy::imports().glScissorArrayvNV(first, count, v);
        GAPID_DEBUG("glScissorArrayvNV() -- done");
    }
}
EXPORT void STDCALL glScissorIndexedNV(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissorIndexedNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", index, left, bottom, width, height);
    if (s->enter("glScissorIndexedNV")) {
        s->glScissorIndexedNV(index, left, bottom, width, height);
        s->exit();
        GAPID_DEBUG("glScissorIndexedNV() -- done");
    } else {
        GAPID_INFO("glScissorIndexedNV at %p: GAPII re-entered. Just invoking imported function at %p", glScissorIndexedNV, s->GlesSpy::imports().glScissorIndexedNV);
        s->GlesSpy::imports().glScissorIndexedNV(index, left, bottom, width, height);
        GAPID_DEBUG("glScissorIndexedNV() -- done");
    }
}
EXPORT void STDCALL glScissorIndexedvNV(GLuint index, GLint* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissorIndexedvNV(%" PRIu32 ", %p)", index, v);
    if (s->enter("glScissorIndexedvNV")) {
        s->glScissorIndexedvNV(index, v);
        s->exit();
        GAPID_DEBUG("glScissorIndexedvNV() -- done");
    } else {
        GAPID_INFO("glScissorIndexedvNV at %p: GAPII re-entered. Just invoking imported function at %p", glScissorIndexedvNV, s->GlesSpy::imports().glScissorIndexedvNV);
        s->GlesSpy::imports().glScissorIndexedvNV(index, v);
        GAPID_DEBUG("glScissorIndexedvNV() -- done");
    }
}
EXPORT void STDCALL glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSelectPerfMonitorCountersAMD(%" PRIu32 ", %" PRIu8 ", %" PRIu32 ", %" PRId32 ", %p)", monitor, enable, group, numCounters, counterList);
    if (s->enter("glSelectPerfMonitorCountersAMD")) {
        s->glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
        s->exit();
        GAPID_DEBUG("glSelectPerfMonitorCountersAMD() -- done");
    } else {
        GAPID_INFO("glSelectPerfMonitorCountersAMD at %p: GAPII re-entered. Just invoking imported function at %p", glSelectPerfMonitorCountersAMD, s->GlesSpy::imports().glSelectPerfMonitorCountersAMD);
        s->GlesSpy::imports().glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
        GAPID_DEBUG("glSelectPerfMonitorCountersAMD() -- done");
    }
}
EXPORT void STDCALL glSetFenceNV(GLuint fence, uint32_t condition) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSetFenceNV(%" PRIu32 ", %u)", fence, condition);
    if (s->enter("glSetFenceNV")) {
        s->glSetFenceNV(fence, condition);
        s->exit();
        GAPID_DEBUG("glSetFenceNV() -- done");
    } else {
        GAPID_INFO("glSetFenceNV at %p: GAPII re-entered. Just invoking imported function at %p", glSetFenceNV, s->GlesSpy::imports().glSetFenceNV);
        s->GlesSpy::imports().glSetFenceNV(fence, condition);
        GAPID_DEBUG("glSetFenceNV() -- done");
    }
}
EXPORT void STDCALL glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, uint32_t preserveMask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStartTilingQCOM(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %u)", x, y, width, height, preserveMask);
    if (s->enter("glStartTilingQCOM")) {
        s->glStartTilingQCOM(x, y, width, height, preserveMask);
        s->exit();
        GAPID_DEBUG("glStartTilingQCOM() -- done");
    } else {
        GAPID_INFO("glStartTilingQCOM at %p: GAPII re-entered. Just invoking imported function at %p", glStartTilingQCOM, s->GlesSpy::imports().glStartTilingQCOM);
        s->GlesSpy::imports().glStartTilingQCOM(x, y, width, height, preserveMask);
        GAPID_DEBUG("glStartTilingQCOM() -- done");
    }
}
EXPORT void STDCALL glStencilFillPathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t fillMode, GLuint mask, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %" PRIu32 ", %u, %p)", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
    if (s->enter("glStencilFillPathInstancedNV")) {
        s->glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glStencilFillPathInstancedNV() -- done");
    } else {
        GAPID_INFO("glStencilFillPathInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilFillPathInstancedNV, s->GlesSpy::imports().glStencilFillPathInstancedNV);
        s->GlesSpy::imports().glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
        GAPID_DEBUG("glStencilFillPathInstancedNV() -- done");
    }
}
EXPORT void STDCALL glStencilFillPathNV(GLuint path, uint32_t fillMode, GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilFillPathNV(%" PRIu32 ", %u, %" PRIu32 ")", path, fillMode, mask);
    if (s->enter("glStencilFillPathNV")) {
        s->glStencilFillPathNV(path, fillMode, mask);
        s->exit();
        GAPID_DEBUG("glStencilFillPathNV() -- done");
    } else {
        GAPID_INFO("glStencilFillPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilFillPathNV, s->GlesSpy::imports().glStencilFillPathNV);
        s->GlesSpy::imports().glStencilFillPathNV(path, fillMode, mask);
        GAPID_DEBUG("glStencilFillPathNV() -- done");
    }
}
EXPORT void STDCALL glStencilStrokePathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLint reference, GLuint mask, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %u, %p)", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
    if (s->enter("glStencilStrokePathInstancedNV")) {
        s->glStencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glStencilStrokePathInstancedNV() -- done");
    } else {
        GAPID_INFO("glStencilStrokePathInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilStrokePathInstancedNV, s->GlesSpy::imports().glStencilStrokePathInstancedNV);
        s->GlesSpy::imports().glStencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
        GAPID_DEBUG("glStencilStrokePathInstancedNV() -- done");
    }
}
EXPORT void STDCALL glStencilStrokePathNV(GLuint path, GLint reference, GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilStrokePathNV(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")", path, reference, mask);
    if (s->enter("glStencilStrokePathNV")) {
        s->glStencilStrokePathNV(path, reference, mask);
        s->exit();
        GAPID_DEBUG("glStencilStrokePathNV() -- done");
    } else {
        GAPID_INFO("glStencilStrokePathNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilStrokePathNV, s->GlesSpy::imports().glStencilStrokePathNV);
        s->GlesSpy::imports().glStencilStrokePathNV(path, reference, mask);
        GAPID_DEBUG("glStencilStrokePathNV() -- done");
    }
}
EXPORT void STDCALL glStencilThenCoverFillPathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, uint32_t fillMode, GLuint mask, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilThenCoverFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
    if (s->enter("glStencilThenCoverFillPathInstancedNV")) {
        s->glStencilThenCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glStencilThenCoverFillPathInstancedNV() -- done");
    } else {
        GAPID_INFO("glStencilThenCoverFillPathInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilThenCoverFillPathInstancedNV, s->GlesSpy::imports().glStencilThenCoverFillPathInstancedNV);
        s->GlesSpy::imports().glStencilThenCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
        GAPID_DEBUG("glStencilThenCoverFillPathInstancedNV() -- done");
    }
}
EXPORT void STDCALL glStencilThenCoverFillPathNV(GLuint path, uint32_t fillMode, GLuint mask, uint32_t coverMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilThenCoverFillPathNV(%" PRIu32 ", %u, %" PRIu32 ", %u)", path, fillMode, mask, coverMode);
    if (s->enter("glStencilThenCoverFillPathNV")) {
        s->glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
        s->exit();
        GAPID_DEBUG("glStencilThenCoverFillPathNV() -- done");
    } else {
        GAPID_INFO("glStencilThenCoverFillPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilThenCoverFillPathNV, s->GlesSpy::imports().glStencilThenCoverFillPathNV);
        s->GlesSpy::imports().glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
        GAPID_DEBUG("glStencilThenCoverFillPathNV() -- done");
    }
}
EXPORT void STDCALL glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths, uint32_t pathNameType, void* paths, GLuint pathBase, GLint reference, GLuint mask, uint32_t coverMode, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilThenCoverStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
    if (s->enter("glStencilThenCoverStrokePathInstancedNV")) {
        s->glStencilThenCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glStencilThenCoverStrokePathInstancedNV() -- done");
    } else {
        GAPID_INFO("glStencilThenCoverStrokePathInstancedNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilThenCoverStrokePathInstancedNV, s->GlesSpy::imports().glStencilThenCoverStrokePathInstancedNV);
        s->GlesSpy::imports().glStencilThenCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
        GAPID_DEBUG("glStencilThenCoverStrokePathInstancedNV() -- done");
    }
}
EXPORT void STDCALL glStencilThenCoverStrokePathNV(GLuint path, GLint reference, GLuint mask, uint32_t coverMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilThenCoverStrokePathNV(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %u)", path, reference, mask, coverMode);
    if (s->enter("glStencilThenCoverStrokePathNV")) {
        s->glStencilThenCoverStrokePathNV(path, reference, mask, coverMode);
        s->exit();
        GAPID_DEBUG("glStencilThenCoverStrokePathNV() -- done");
    } else {
        GAPID_INFO("glStencilThenCoverStrokePathNV at %p: GAPII re-entered. Just invoking imported function at %p", glStencilThenCoverStrokePathNV, s->GlesSpy::imports().glStencilThenCoverStrokePathNV);
        s->GlesSpy::imports().glStencilThenCoverStrokePathNV(path, reference, mask, coverMode);
        GAPID_DEBUG("glStencilThenCoverStrokePathNV() -- done");
    }
}
EXPORT void STDCALL glSubpixelPrecisionBiasNV(GLuint xbits, GLuint ybits) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSubpixelPrecisionBiasNV(%" PRIu32 ", %" PRIu32 ")", xbits, ybits);
    if (s->enter("glSubpixelPrecisionBiasNV")) {
        s->glSubpixelPrecisionBiasNV(xbits, ybits);
        s->exit();
        GAPID_DEBUG("glSubpixelPrecisionBiasNV() -- done");
    } else {
        GAPID_INFO("glSubpixelPrecisionBiasNV at %p: GAPII re-entered. Just invoking imported function at %p", glSubpixelPrecisionBiasNV, s->GlesSpy::imports().glSubpixelPrecisionBiasNV);
        s->GlesSpy::imports().glSubpixelPrecisionBiasNV(xbits, ybits);
        GAPID_DEBUG("glSubpixelPrecisionBiasNV() -- done");
    }
}
EXPORT GLboolean STDCALL glTestFenceNV(GLuint fence) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTestFenceNV(%" PRIu32 ")", fence);
    if (s->enter("glTestFenceNV")) {
        auto _result_ = s->glTestFenceNV(fence);
        s->exit();
        GAPID_DEBUG("glTestFenceNV() -- done");
        return _result_;
    } else {
        GAPID_INFO("glTestFenceNV at %p: GAPII re-entered. Just invoking imported function at %p", glTestFenceNV, s->GlesSpy::imports().glTestFenceNV);
        auto _result_ = s->GlesSpy::imports().glTestFenceNV(fence);
        GAPID_DEBUG("glTestFenceNV() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glTexBufferOES(uint32_t target, uint32_t internalformat, BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexBufferOES(%u, %u, %" PRIu32 ")", target, internalformat, buffer);
    if (s->enter("glTexBufferOES")) {
        s->glTexBufferOES(target, internalformat, buffer);
        s->exit();
        GAPID_DEBUG("glTexBufferOES() -- done");
    } else {
        GAPID_INFO("glTexBufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexBufferOES, s->GlesSpy::imports().glTexBufferOES);
        s->GlesSpy::imports().glTexBufferOES(target, internalformat, buffer);
        GAPID_DEBUG("glTexBufferOES() -- done");
    }
}
EXPORT void STDCALL glTexBufferRangeOES(uint32_t target, uint32_t internalformat, BufferId buffer, GLintptr offset, GLsizeiptr size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexBufferRangeOES(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, internalformat, buffer, offset, size);
    if (s->enter("glTexBufferRangeOES")) {
        s->glTexBufferRangeOES(target, internalformat, buffer, offset, size);
        s->exit();
        GAPID_DEBUG("glTexBufferRangeOES() -- done");
    } else {
        GAPID_INFO("glTexBufferRangeOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexBufferRangeOES, s->GlesSpy::imports().glTexBufferRangeOES);
        s->GlesSpy::imports().glTexBufferRangeOES(target, internalformat, buffer, offset, size);
        GAPID_DEBUG("glTexBufferRangeOES() -- done");
    }
}
EXPORT void STDCALL glTexImage3DOES(uint32_t target, GLint level, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, uint32_t format, uint32_t type, TexturePointer pixels) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexImage3DOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, internalformat, width, height, depth, border, format, type, pixels);
    if (s->enter("glTexImage3DOES")) {
        s->glTexImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels);
        s->exit();
        GAPID_DEBUG("glTexImage3DOES() -- done");
    } else {
        GAPID_INFO("glTexImage3DOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexImage3DOES, s->GlesSpy::imports().glTexImage3DOES);
        s->GlesSpy::imports().glTexImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels);
        GAPID_DEBUG("glTexImage3DOES() -- done");
    }
}
EXPORT void STDCALL glTexPageCommitmentEXT(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexPageCommitmentEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
    if (s->enter("glTexPageCommitmentEXT")) {
        s->glTexPageCommitmentEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
        s->exit();
        GAPID_DEBUG("glTexPageCommitmentEXT() -- done");
    } else {
        GAPID_INFO("glTexPageCommitmentEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexPageCommitmentEXT, s->GlesSpy::imports().glTexPageCommitmentEXT);
        s->GlesSpy::imports().glTexPageCommitmentEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
        GAPID_DEBUG("glTexPageCommitmentEXT() -- done");
    }
}
EXPORT void STDCALL glTexParameterIivOES(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterIivOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterIivOES")) {
        s->glTexParameterIivOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterIivOES() -- done");
    } else {
        GAPID_INFO("glTexParameterIivOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterIivOES, s->GlesSpy::imports().glTexParameterIivOES);
        s->GlesSpy::imports().glTexParameterIivOES(target, pname, params);
        GAPID_DEBUG("glTexParameterIivOES() -- done");
    }
}
EXPORT void STDCALL glTexParameterIuivOES(uint32_t target, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterIuivOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterIuivOES")) {
        s->glTexParameterIuivOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterIuivOES() -- done");
    } else {
        GAPID_INFO("glTexParameterIuivOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterIuivOES, s->GlesSpy::imports().glTexParameterIuivOES);
        s->GlesSpy::imports().glTexParameterIuivOES(target, pname, params);
        GAPID_DEBUG("glTexParameterIuivOES() -- done");
    }
}
EXPORT void STDCALL glTexStorage1DEXT(uint32_t target, GLsizei levels, uint32_t format, GLsizei width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage1DEXT(%u, %" PRId32 ", %u, %" PRId32 ")", target, levels, format, width);
    if (s->enter("glTexStorage1DEXT")) {
        s->glTexStorage1DEXT(target, levels, format, width);
        s->exit();
        GAPID_DEBUG("glTexStorage1DEXT() -- done");
    } else {
        GAPID_INFO("glTexStorage1DEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage1DEXT, s->GlesSpy::imports().glTexStorage1DEXT);
        s->GlesSpy::imports().glTexStorage1DEXT(target, levels, format, width);
        GAPID_DEBUG("glTexStorage1DEXT() -- done");
    }
}
EXPORT void STDCALL glTexStorage2DEXT(uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage2DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, levels, format, width, height);
    if (s->enter("glTexStorage2DEXT")) {
        s->glTexStorage2DEXT(target, levels, format, width, height);
        s->exit();
        GAPID_DEBUG("glTexStorage2DEXT() -- done");
    } else {
        GAPID_INFO("glTexStorage2DEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage2DEXT, s->GlesSpy::imports().glTexStorage2DEXT);
        s->GlesSpy::imports().glTexStorage2DEXT(target, levels, format, width, height);
        GAPID_DEBUG("glTexStorage2DEXT() -- done");
    }
}
EXPORT void STDCALL glTexStorage3DEXT(uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height, GLsizei depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage3DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, levels, format, width, height, depth);
    if (s->enter("glTexStorage3DEXT")) {
        s->glTexStorage3DEXT(target, levels, format, width, height, depth);
        s->exit();
        GAPID_DEBUG("glTexStorage3DEXT() -- done");
    } else {
        GAPID_INFO("glTexStorage3DEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage3DEXT, s->GlesSpy::imports().glTexStorage3DEXT);
        s->GlesSpy::imports().glTexStorage3DEXT(target, levels, format, width, height, depth);
        GAPID_DEBUG("glTexStorage3DEXT() -- done");
    }
}
EXPORT void STDCALL glTexSubImage3DOES(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, TexturePointer pixels) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexSubImage3DOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
    if (s->enter("glTexSubImage3DOES")) {
        s->glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
        s->exit();
        GAPID_DEBUG("glTexSubImage3DOES() -- done");
    } else {
        GAPID_INFO("glTexSubImage3DOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexSubImage3DOES, s->GlesSpy::imports().glTexSubImage3DOES);
        s->GlesSpy::imports().glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
        GAPID_DEBUG("glTexSubImage3DOES() -- done");
    }
}
EXPORT void STDCALL glTextureStorage1DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t format, GLsizei width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureStorage1DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ")", texture, target, levels, format, width);
    if (s->enter("glTextureStorage1DEXT")) {
        s->glTextureStorage1DEXT(texture, target, levels, format, width);
        s->exit();
        GAPID_DEBUG("glTextureStorage1DEXT() -- done");
    } else {
        GAPID_INFO("glTextureStorage1DEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTextureStorage1DEXT, s->GlesSpy::imports().glTextureStorage1DEXT);
        s->GlesSpy::imports().glTextureStorage1DEXT(texture, target, levels, format, width);
        GAPID_DEBUG("glTextureStorage1DEXT() -- done");
    }
}
EXPORT void STDCALL glTextureStorage2DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureStorage2DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", texture, target, levels, format, width, height);
    if (s->enter("glTextureStorage2DEXT")) {
        s->glTextureStorage2DEXT(texture, target, levels, format, width, height);
        s->exit();
        GAPID_DEBUG("glTextureStorage2DEXT() -- done");
    } else {
        GAPID_INFO("glTextureStorage2DEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTextureStorage2DEXT, s->GlesSpy::imports().glTextureStorage2DEXT);
        s->GlesSpy::imports().glTextureStorage2DEXT(texture, target, levels, format, width, height);
        GAPID_DEBUG("glTextureStorage2DEXT() -- done");
    }
}
EXPORT void STDCALL glTextureStorage3DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t format, GLsizei width, GLsizei height, GLsizei depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureStorage3DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, target, levels, format, width, height, depth);
    if (s->enter("glTextureStorage3DEXT")) {
        s->glTextureStorage3DEXT(texture, target, levels, format, width, height, depth);
        s->exit();
        GAPID_DEBUG("glTextureStorage3DEXT() -- done");
    } else {
        GAPID_INFO("glTextureStorage3DEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTextureStorage3DEXT, s->GlesSpy::imports().glTextureStorage3DEXT);
        s->GlesSpy::imports().glTextureStorage3DEXT(texture, target, levels, format, width, height, depth);
        GAPID_DEBUG("glTextureStorage3DEXT() -- done");
    }
}
EXPORT void STDCALL glTextureViewEXT(TextureId texture, uint32_t target, GLuint origtexture, uint32_t internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureViewEXT(%" PRIu32 ", %u, %" PRIu32 ", %u, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
    if (s->enter("glTextureViewEXT")) {
        s->glTextureViewEXT(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
        s->exit();
        GAPID_DEBUG("glTextureViewEXT() -- done");
    } else {
        GAPID_INFO("glTextureViewEXT at %p: GAPII re-entered. Just invoking imported function at %p", glTextureViewEXT, s->GlesSpy::imports().glTextureViewEXT);
        s->GlesSpy::imports().glTextureViewEXT(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
        GAPID_DEBUG("glTextureViewEXT() -- done");
    }
}
EXPORT void STDCALL glTextureViewOES(TextureId texture, uint32_t target, GLuint origtexture, uint32_t internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureViewOES(%" PRIu32 ", %u, %" PRIu32 ", %u, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
    if (s->enter("glTextureViewOES")) {
        s->glTextureViewOES(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
        s->exit();
        GAPID_DEBUG("glTextureViewOES() -- done");
    } else {
        GAPID_INFO("glTextureViewOES at %p: GAPII re-entered. Just invoking imported function at %p", glTextureViewOES, s->GlesSpy::imports().glTextureViewOES);
        s->GlesSpy::imports().glTextureViewOES(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
        GAPID_DEBUG("glTextureViewOES() -- done");
    }
}
EXPORT void STDCALL glTransformPathNV(GLuint resultPath, GLuint srcPath, uint32_t transformType, GLfloat* transformValues) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTransformPathNV(%" PRIu32 ", %" PRIu32 ", %u, %p)", resultPath, srcPath, transformType, transformValues);
    if (s->enter("glTransformPathNV")) {
        s->glTransformPathNV(resultPath, srcPath, transformType, transformValues);
        s->exit();
        GAPID_DEBUG("glTransformPathNV() -- done");
    } else {
        GAPID_INFO("glTransformPathNV at %p: GAPII re-entered. Just invoking imported function at %p", glTransformPathNV, s->GlesSpy::imports().glTransformPathNV);
        s->GlesSpy::imports().glTransformPathNV(resultPath, srcPath, transformType, transformValues);
        GAPID_DEBUG("glTransformPathNV() -- done");
    }
}
EXPORT void STDCALL glUniformHandleui64NV(UniformLocation location, GLuint64 value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformHandleui64NV(%" PRId32 ", %" PRIu64 ")", location, value);
    if (s->enter("glUniformHandleui64NV")) {
        s->glUniformHandleui64NV(location, value);
        s->exit();
        GAPID_DEBUG("glUniformHandleui64NV() -- done");
    } else {
        GAPID_INFO("glUniformHandleui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformHandleui64NV, s->GlesSpy::imports().glUniformHandleui64NV);
        s->GlesSpy::imports().glUniformHandleui64NV(location, value);
        GAPID_DEBUG("glUniformHandleui64NV() -- done");
    }
}
EXPORT void STDCALL glUniformHandleui64vNV(UniformLocation location, GLsizei count, GLuint64* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformHandleui64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (s->enter("glUniformHandleui64vNV")) {
        s->glUniformHandleui64vNV(location, count, value);
        s->exit();
        GAPID_DEBUG("glUniformHandleui64vNV() -- done");
    } else {
        GAPID_INFO("glUniformHandleui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformHandleui64vNV, s->GlesSpy::imports().glUniformHandleui64vNV);
        s->GlesSpy::imports().glUniformHandleui64vNV(location, count, value);
        GAPID_DEBUG("glUniformHandleui64vNV() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix2x3fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix2x3fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
    if (s->enter("glUniformMatrix2x3fvNV")) {
        s->glUniformMatrix2x3fvNV(location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glUniformMatrix2x3fvNV() -- done");
    } else {
        GAPID_INFO("glUniformMatrix2x3fvNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix2x3fvNV, s->GlesSpy::imports().glUniformMatrix2x3fvNV);
        s->GlesSpy::imports().glUniformMatrix2x3fvNV(location, count, transpose, value);
        GAPID_DEBUG("glUniformMatrix2x3fvNV() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix2x4fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix2x4fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
    if (s->enter("glUniformMatrix2x4fvNV")) {
        s->glUniformMatrix2x4fvNV(location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glUniformMatrix2x4fvNV() -- done");
    } else {
        GAPID_INFO("glUniformMatrix2x4fvNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix2x4fvNV, s->GlesSpy::imports().glUniformMatrix2x4fvNV);
        s->GlesSpy::imports().glUniformMatrix2x4fvNV(location, count, transpose, value);
        GAPID_DEBUG("glUniformMatrix2x4fvNV() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix3x2fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix3x2fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
    if (s->enter("glUniformMatrix3x2fvNV")) {
        s->glUniformMatrix3x2fvNV(location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glUniformMatrix3x2fvNV() -- done");
    } else {
        GAPID_INFO("glUniformMatrix3x2fvNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix3x2fvNV, s->GlesSpy::imports().glUniformMatrix3x2fvNV);
        s->GlesSpy::imports().glUniformMatrix3x2fvNV(location, count, transpose, value);
        GAPID_DEBUG("glUniformMatrix3x2fvNV() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix3x4fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix3x4fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
    if (s->enter("glUniformMatrix3x4fvNV")) {
        s->glUniformMatrix3x4fvNV(location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glUniformMatrix3x4fvNV() -- done");
    } else {
        GAPID_INFO("glUniformMatrix3x4fvNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix3x4fvNV, s->GlesSpy::imports().glUniformMatrix3x4fvNV);
        s->GlesSpy::imports().glUniformMatrix3x4fvNV(location, count, transpose, value);
        GAPID_DEBUG("glUniformMatrix3x4fvNV() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix4x2fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix4x2fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
    if (s->enter("glUniformMatrix4x2fvNV")) {
        s->glUniformMatrix4x2fvNV(location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glUniformMatrix4x2fvNV() -- done");
    } else {
        GAPID_INFO("glUniformMatrix4x2fvNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix4x2fvNV, s->GlesSpy::imports().glUniformMatrix4x2fvNV);
        s->GlesSpy::imports().glUniformMatrix4x2fvNV(location, count, transpose, value);
        GAPID_DEBUG("glUniformMatrix4x2fvNV() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix4x3fvNV(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix4x3fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
    if (s->enter("glUniformMatrix4x3fvNV")) {
        s->glUniformMatrix4x3fvNV(location, count, transpose, value);
        s->exit();
        GAPID_DEBUG("glUniformMatrix4x3fvNV() -- done");
    } else {
        GAPID_INFO("glUniformMatrix4x3fvNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix4x3fvNV, s->GlesSpy::imports().glUniformMatrix4x3fvNV);
        s->GlesSpy::imports().glUniformMatrix4x3fvNV(location, count, transpose, value);
        GAPID_DEBUG("glUniformMatrix4x3fvNV() -- done");
    }
}
EXPORT GLboolean STDCALL glUnmapBufferOES(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUnmapBufferOES(%u)", target);
    if (s->enter("glUnmapBufferOES")) {
        auto _result_ = s->glUnmapBufferOES(target);
        s->exit();
        GAPID_DEBUG("glUnmapBufferOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glUnmapBufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glUnmapBufferOES, s->GlesSpy::imports().glUnmapBufferOES);
        auto _result_ = s->GlesSpy::imports().glUnmapBufferOES(target);
        GAPID_DEBUG("glUnmapBufferOES() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glUseProgramStagesEXT(PipelineId pipeline, uint32_t stages, ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUseProgramStagesEXT(%" PRIu32 ", %u, %" PRIu32 ")", pipeline, stages, program);
    if (s->enter("glUseProgramStagesEXT")) {
        s->glUseProgramStagesEXT(pipeline, stages, program);
        s->exit();
        GAPID_DEBUG("glUseProgramStagesEXT() -- done");
    } else {
        GAPID_INFO("glUseProgramStagesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glUseProgramStagesEXT, s->GlesSpy::imports().glUseProgramStagesEXT);
        s->GlesSpy::imports().glUseProgramStagesEXT(pipeline, stages, program);
        GAPID_DEBUG("glUseProgramStagesEXT() -- done");
    }
}
EXPORT void STDCALL glValidateProgramPipelineEXT(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glValidateProgramPipelineEXT(%" PRIu32 ")", pipeline);
    if (s->enter("glValidateProgramPipelineEXT")) {
        s->glValidateProgramPipelineEXT(pipeline);
        s->exit();
        GAPID_DEBUG("glValidateProgramPipelineEXT() -- done");
    } else {
        GAPID_INFO("glValidateProgramPipelineEXT at %p: GAPII re-entered. Just invoking imported function at %p", glValidateProgramPipelineEXT, s->GlesSpy::imports().glValidateProgramPipelineEXT);
        s->GlesSpy::imports().glValidateProgramPipelineEXT(pipeline);
        GAPID_DEBUG("glValidateProgramPipelineEXT() -- done");
    }
}
EXPORT void STDCALL glVertexAttribDivisorANGLE(AttributeLocation index, GLuint divisor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribDivisorANGLE(%" PRIu32 ", %" PRIu32 ")", index, divisor);
    if (s->enter("glVertexAttribDivisorANGLE")) {
        s->glVertexAttribDivisorANGLE(index, divisor);
        s->exit();
        GAPID_DEBUG("glVertexAttribDivisorANGLE() -- done");
    } else {
        GAPID_INFO("glVertexAttribDivisorANGLE at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribDivisorANGLE, s->GlesSpy::imports().glVertexAttribDivisorANGLE);
        s->GlesSpy::imports().glVertexAttribDivisorANGLE(index, divisor);
        GAPID_DEBUG("glVertexAttribDivisorANGLE() -- done");
    }
}
EXPORT void STDCALL glVertexAttribDivisorEXT(AttributeLocation index, GLuint divisor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribDivisorEXT(%" PRIu32 ", %" PRIu32 ")", index, divisor);
    if (s->enter("glVertexAttribDivisorEXT")) {
        s->glVertexAttribDivisorEXT(index, divisor);
        s->exit();
        GAPID_DEBUG("glVertexAttribDivisorEXT() -- done");
    } else {
        GAPID_INFO("glVertexAttribDivisorEXT at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribDivisorEXT, s->GlesSpy::imports().glVertexAttribDivisorEXT);
        s->GlesSpy::imports().glVertexAttribDivisorEXT(index, divisor);
        GAPID_DEBUG("glVertexAttribDivisorEXT() -- done");
    }
}
EXPORT void STDCALL glVertexAttribDivisorNV(AttributeLocation index, GLuint divisor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribDivisorNV(%" PRIu32 ", %" PRIu32 ")", index, divisor);
    if (s->enter("glVertexAttribDivisorNV")) {
        s->glVertexAttribDivisorNV(index, divisor);
        s->exit();
        GAPID_DEBUG("glVertexAttribDivisorNV() -- done");
    } else {
        GAPID_INFO("glVertexAttribDivisorNV at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribDivisorNV, s->GlesSpy::imports().glVertexAttribDivisorNV);
        s->GlesSpy::imports().glVertexAttribDivisorNV(index, divisor);
        GAPID_DEBUG("glVertexAttribDivisorNV() -- done");
    }
}
EXPORT void STDCALL glViewportArrayvNV(GLuint first, GLsizei count, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportArrayvNV(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
    if (s->enter("glViewportArrayvNV")) {
        s->glViewportArrayvNV(first, count, v);
        s->exit();
        GAPID_DEBUG("glViewportArrayvNV() -- done");
    } else {
        GAPID_INFO("glViewportArrayvNV at %p: GAPII re-entered. Just invoking imported function at %p", glViewportArrayvNV, s->GlesSpy::imports().glViewportArrayvNV);
        s->GlesSpy::imports().glViewportArrayvNV(first, count, v);
        GAPID_DEBUG("glViewportArrayvNV() -- done");
    }
}
EXPORT void STDCALL glViewportIndexedfNV(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportIndexedfNV(%" PRIu32 ", %f, %f, %f, %f)", index, x, y, w, h);
    if (s->enter("glViewportIndexedfNV")) {
        s->glViewportIndexedfNV(index, x, y, w, h);
        s->exit();
        GAPID_DEBUG("glViewportIndexedfNV() -- done");
    } else {
        GAPID_INFO("glViewportIndexedfNV at %p: GAPII re-entered. Just invoking imported function at %p", glViewportIndexedfNV, s->GlesSpy::imports().glViewportIndexedfNV);
        s->GlesSpy::imports().glViewportIndexedfNV(index, x, y, w, h);
        GAPID_DEBUG("glViewportIndexedfNV() -- done");
    }
}
EXPORT void STDCALL glViewportIndexedfvNV(GLuint index, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportIndexedfvNV(%" PRIu32 ", %p)", index, v);
    if (s->enter("glViewportIndexedfvNV")) {
        s->glViewportIndexedfvNV(index, v);
        s->exit();
        GAPID_DEBUG("glViewportIndexedfvNV() -- done");
    } else {
        GAPID_INFO("glViewportIndexedfvNV at %p: GAPII re-entered. Just invoking imported function at %p", glViewportIndexedfvNV, s->GlesSpy::imports().glViewportIndexedfvNV);
        s->GlesSpy::imports().glViewportIndexedfvNV(index, v);
        GAPID_DEBUG("glViewportIndexedfvNV() -- done");
    }
}
EXPORT void STDCALL glWaitSyncAPPLE(GLsync sync, uint32_t flag, GLuint64 timeout) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glWaitSyncAPPLE(%p, %u, %" PRIu64 ")", sync, flag, timeout);
    if (s->enter("glWaitSyncAPPLE")) {
        s->glWaitSyncAPPLE(sync, flag, timeout);
        s->exit();
        GAPID_DEBUG("glWaitSyncAPPLE() -- done");
    } else {
        GAPID_INFO("glWaitSyncAPPLE at %p: GAPII re-entered. Just invoking imported function at %p", glWaitSyncAPPLE, s->GlesSpy::imports().glWaitSyncAPPLE);
        s->GlesSpy::imports().glWaitSyncAPPLE(sync, flag, timeout);
        GAPID_DEBUG("glWaitSyncAPPLE() -- done");
    }
}
EXPORT void STDCALL glWeightPathsNV(GLuint resultPath, GLsizei numPaths, GLuint* paths, GLfloat* weights) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glWeightPathsNV(%" PRIu32 ", %" PRId32 ", %p, %p)", resultPath, numPaths, paths, weights);
    if (s->enter("glWeightPathsNV")) {
        s->glWeightPathsNV(resultPath, numPaths, paths, weights);
        s->exit();
        GAPID_DEBUG("glWeightPathsNV() -- done");
    } else {
        GAPID_INFO("glWeightPathsNV at %p: GAPII re-entered. Just invoking imported function at %p", glWeightPathsNV, s->GlesSpy::imports().glWeightPathsNV);
        s->GlesSpy::imports().glWeightPathsNV(resultPath, numPaths, paths, weights);
        GAPID_DEBUG("glWeightPathsNV() -- done");
    }
}
EXPORT void STDCALL glBlendBarrier() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendBarrier()");
    if (s->enter("glBlendBarrier")) {
        s->glBlendBarrier();
        s->exit();
        GAPID_DEBUG("glBlendBarrier() -- done");
    } else {
        GAPID_INFO("glBlendBarrier at %p: GAPII re-entered. Just invoking imported function at %p", glBlendBarrier, s->GlesSpy::imports().glBlendBarrier);
        s->GlesSpy::imports().glBlendBarrier();
        GAPID_DEBUG("glBlendBarrier() -- done");
    }
}
EXPORT void STDCALL glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendColor(%f, %f, %f, %f)", red, green, blue, alpha);
    if (s->enter("glBlendColor")) {
        s->glBlendColor(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glBlendColor() -- done");
    } else {
        GAPID_INFO("glBlendColor at %p: GAPII re-entered. Just invoking imported function at %p", glBlendColor, s->GlesSpy::imports().glBlendColor);
        s->GlesSpy::imports().glBlendColor(red, green, blue, alpha);
        GAPID_DEBUG("glBlendColor() -- done");
    }
}
EXPORT void STDCALL glBlendEquation(uint32_t equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquation(%u)", equation);
    if (s->enter("glBlendEquation")) {
        s->glBlendEquation(equation);
        s->exit();
        GAPID_DEBUG("glBlendEquation() -- done");
    } else {
        GAPID_INFO("glBlendEquation at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquation, s->GlesSpy::imports().glBlendEquation);
        s->GlesSpy::imports().glBlendEquation(equation);
        GAPID_DEBUG("glBlendEquation() -- done");
    }
}
EXPORT void STDCALL glBlendEquationSeparate(uint32_t rgb, uint32_t alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationSeparate(%u, %u)", rgb, alpha);
    if (s->enter("glBlendEquationSeparate")) {
        s->glBlendEquationSeparate(rgb, alpha);
        s->exit();
        GAPID_DEBUG("glBlendEquationSeparate() -- done");
    } else {
        GAPID_INFO("glBlendEquationSeparate at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationSeparate, s->GlesSpy::imports().glBlendEquationSeparate);
        s->GlesSpy::imports().glBlendEquationSeparate(rgb, alpha);
        GAPID_DEBUG("glBlendEquationSeparate() -- done");
    }
}
EXPORT void STDCALL glBlendEquationSeparatei(DrawBufferIndex buf, uint32_t modeRGB, uint32_t modeAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationSeparatei(%" PRIu32 ", %u, %u)", buf, modeRGB, modeAlpha);
    if (s->enter("glBlendEquationSeparatei")) {
        s->glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
        s->exit();
        GAPID_DEBUG("glBlendEquationSeparatei() -- done");
    } else {
        GAPID_INFO("glBlendEquationSeparatei at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationSeparatei, s->GlesSpy::imports().glBlendEquationSeparatei);
        s->GlesSpy::imports().glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
        GAPID_DEBUG("glBlendEquationSeparatei() -- done");
    }
}
EXPORT void STDCALL glBlendEquationi(DrawBufferIndex buf, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationi(%" PRIu32 ", %u)", buf, mode);
    if (s->enter("glBlendEquationi")) {
        s->glBlendEquationi(buf, mode);
        s->exit();
        GAPID_DEBUG("glBlendEquationi() -- done");
    } else {
        GAPID_INFO("glBlendEquationi at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationi, s->GlesSpy::imports().glBlendEquationi);
        s->GlesSpy::imports().glBlendEquationi(buf, mode);
        GAPID_DEBUG("glBlendEquationi() -- done");
    }
}
EXPORT void STDCALL glBlendFunc(uint32_t src_factor, uint32_t dst_factor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFunc(%u, %u)", src_factor, dst_factor);
    if (s->enter("glBlendFunc")) {
        s->glBlendFunc(src_factor, dst_factor);
        s->exit();
        GAPID_DEBUG("glBlendFunc() -- done");
    } else {
        GAPID_INFO("glBlendFunc at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFunc, s->GlesSpy::imports().glBlendFunc);
        s->GlesSpy::imports().glBlendFunc(src_factor, dst_factor);
        GAPID_DEBUG("glBlendFunc() -- done");
    }
}
EXPORT void STDCALL glBlendFuncSeparate(uint32_t src_factor_rgb, uint32_t dst_factor_rgb, uint32_t src_factor_alpha, uint32_t dst_factor_alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFuncSeparate(%u, %u, %u, %u)", src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
    if (s->enter("glBlendFuncSeparate")) {
        s->glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
        s->exit();
        GAPID_DEBUG("glBlendFuncSeparate() -- done");
    } else {
        GAPID_INFO("glBlendFuncSeparate at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFuncSeparate, s->GlesSpy::imports().glBlendFuncSeparate);
        s->GlesSpy::imports().glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
        GAPID_DEBUG("glBlendFuncSeparate() -- done");
    }
}
EXPORT void STDCALL glBlendFuncSeparatei(DrawBufferIndex buf, uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFuncSeparatei(%" PRIu32 ", %u, %u, %u, %u)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
    if (s->enter("glBlendFuncSeparatei")) {
        s->glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
        s->exit();
        GAPID_DEBUG("glBlendFuncSeparatei() -- done");
    } else {
        GAPID_INFO("glBlendFuncSeparatei at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFuncSeparatei, s->GlesSpy::imports().glBlendFuncSeparatei);
        s->GlesSpy::imports().glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
        GAPID_DEBUG("glBlendFuncSeparatei() -- done");
    }
}
EXPORT void STDCALL glBlendFunci(DrawBufferIndex buf, uint32_t src, uint32_t dst) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFunci(%" PRIu32 ", %u, %u)", buf, src, dst);
    if (s->enter("glBlendFunci")) {
        s->glBlendFunci(buf, src, dst);
        s->exit();
        GAPID_DEBUG("glBlendFunci() -- done");
    } else {
        GAPID_INFO("glBlendFunci at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFunci, s->GlesSpy::imports().glBlendFunci);
        s->GlesSpy::imports().glBlendFunci(buf, src, dst);
        GAPID_DEBUG("glBlendFunci() -- done");
    }
}
EXPORT void STDCALL glDepthFunc(uint32_t function) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthFunc(%u)", function);
    if (s->enter("glDepthFunc")) {
        s->glDepthFunc(function);
        s->exit();
        GAPID_DEBUG("glDepthFunc() -- done");
    } else {
        GAPID_INFO("glDepthFunc at %p: GAPII re-entered. Just invoking imported function at %p", glDepthFunc, s->GlesSpy::imports().glDepthFunc);
        s->GlesSpy::imports().glDepthFunc(function);
        GAPID_DEBUG("glDepthFunc() -- done");
    }
}
EXPORT void STDCALL glSampleCoverage(GLfloat value, GLboolean invert) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSampleCoverage(%f, %" PRIu8 ")", value, invert);
    if (s->enter("glSampleCoverage")) {
        s->glSampleCoverage(value, invert);
        s->exit();
        GAPID_DEBUG("glSampleCoverage() -- done");
    } else {
        GAPID_INFO("glSampleCoverage at %p: GAPII re-entered. Just invoking imported function at %p", glSampleCoverage, s->GlesSpy::imports().glSampleCoverage);
        s->GlesSpy::imports().glSampleCoverage(value, invert);
        GAPID_DEBUG("glSampleCoverage() -- done");
    }
}
EXPORT void STDCALL glSampleMaski(GLuint maskNumber, uint32_t mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSampleMaski(%" PRIu32 ", %u)", maskNumber, mask);
    if (s->enter("glSampleMaski")) {
        s->glSampleMaski(maskNumber, mask);
        s->exit();
        GAPID_DEBUG("glSampleMaski() -- done");
    } else {
        GAPID_INFO("glSampleMaski at %p: GAPII re-entered. Just invoking imported function at %p", glSampleMaski, s->GlesSpy::imports().glSampleMaski);
        s->GlesSpy::imports().glSampleMaski(maskNumber, mask);
        GAPID_DEBUG("glSampleMaski() -- done");
    }
}
EXPORT void STDCALL glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissor(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, width, height);
    if (s->enter("glScissor")) {
        s->glScissor(x, y, width, height);
        s->exit();
        GAPID_DEBUG("glScissor() -- done");
    } else {
        GAPID_INFO("glScissor at %p: GAPII re-entered. Just invoking imported function at %p", glScissor, s->GlesSpy::imports().glScissor);
        s->GlesSpy::imports().glScissor(x, y, width, height);
        GAPID_DEBUG("glScissor() -- done");
    }
}
EXPORT void STDCALL glStencilFunc(uint32_t func, GLint ref, GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilFunc(%u, %" PRId32 ", %" PRIu32 ")", func, ref, mask);
    if (s->enter("glStencilFunc")) {
        s->glStencilFunc(func, ref, mask);
        s->exit();
        GAPID_DEBUG("glStencilFunc() -- done");
    } else {
        GAPID_INFO("glStencilFunc at %p: GAPII re-entered. Just invoking imported function at %p", glStencilFunc, s->GlesSpy::imports().glStencilFunc);
        s->GlesSpy::imports().glStencilFunc(func, ref, mask);
        GAPID_DEBUG("glStencilFunc() -- done");
    }
}
EXPORT void STDCALL glStencilFuncSeparate(uint32_t face, uint32_t function, GLint reference_value, GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilFuncSeparate(%u, %u, %" PRId32 ", %" PRIu32 ")", face, function, reference_value, mask);
    if (s->enter("glStencilFuncSeparate")) {
        s->glStencilFuncSeparate(face, function, reference_value, mask);
        s->exit();
        GAPID_DEBUG("glStencilFuncSeparate() -- done");
    } else {
        GAPID_INFO("glStencilFuncSeparate at %p: GAPII re-entered. Just invoking imported function at %p", glStencilFuncSeparate, s->GlesSpy::imports().glStencilFuncSeparate);
        s->GlesSpy::imports().glStencilFuncSeparate(face, function, reference_value, mask);
        GAPID_DEBUG("glStencilFuncSeparate() -- done");
    }
}
EXPORT void STDCALL glStencilOp(uint32_t fail, uint32_t zfail, uint32_t zpass) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilOp(%u, %u, %u)", fail, zfail, zpass);
    if (s->enter("glStencilOp")) {
        s->glStencilOp(fail, zfail, zpass);
        s->exit();
        GAPID_DEBUG("glStencilOp() -- done");
    } else {
        GAPID_INFO("glStencilOp at %p: GAPII re-entered. Just invoking imported function at %p", glStencilOp, s->GlesSpy::imports().glStencilOp);
        s->GlesSpy::imports().glStencilOp(fail, zfail, zpass);
        GAPID_DEBUG("glStencilOp() -- done");
    }
}
EXPORT void STDCALL glStencilOpSeparate(uint32_t face, uint32_t stencil_fail, uint32_t stencil_pass_depth_fail, uint32_t stencil_pass_depth_pass) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilOpSeparate(%u, %u, %u, %u)", face, stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
    if (s->enter("glStencilOpSeparate")) {
        s->glStencilOpSeparate(face, stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
        s->exit();
        GAPID_DEBUG("glStencilOpSeparate() -- done");
    } else {
        GAPID_INFO("glStencilOpSeparate at %p: GAPII re-entered. Just invoking imported function at %p", glStencilOpSeparate, s->GlesSpy::imports().glStencilOpSeparate);
        s->GlesSpy::imports().glStencilOpSeparate(face, stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
        GAPID_DEBUG("glStencilOpSeparate() -- done");
    }
}
EXPORT void STDCALL glBindFramebuffer(uint32_t target, FramebufferId framebuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindFramebuffer(%u, %" PRIu32 ")", target, framebuffer);
    if (s->enter("glBindFramebuffer")) {
        s->glBindFramebuffer(target, framebuffer);
        s->exit();
        GAPID_DEBUG("glBindFramebuffer() -- done");
    } else {
        GAPID_INFO("glBindFramebuffer at %p: GAPII re-entered. Just invoking imported function at %p", glBindFramebuffer, s->GlesSpy::imports().glBindFramebuffer);
        s->GlesSpy::imports().glBindFramebuffer(target, framebuffer);
        GAPID_DEBUG("glBindFramebuffer() -- done");
    }
}
EXPORT void STDCALL glBindRenderbuffer(uint32_t target, RenderbufferId renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindRenderbuffer(%u, %" PRIu32 ")", target, renderbuffer);
    if (s->enter("glBindRenderbuffer")) {
        s->glBindRenderbuffer(target, renderbuffer);
        s->exit();
        GAPID_DEBUG("glBindRenderbuffer() -- done");
    } else {
        GAPID_INFO("glBindRenderbuffer at %p: GAPII re-entered. Just invoking imported function at %p", glBindRenderbuffer, s->GlesSpy::imports().glBindRenderbuffer);
        s->GlesSpy::imports().glBindRenderbuffer(target, renderbuffer);
        GAPID_DEBUG("glBindRenderbuffer() -- done");
    }
}
EXPORT void STDCALL glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, uint32_t mask, uint32_t filter) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlitFramebuffer(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    if (s->enter("glBlitFramebuffer")) {
        s->glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        s->exit();
        GAPID_DEBUG("glBlitFramebuffer() -- done");
    } else {
        GAPID_INFO("glBlitFramebuffer at %p: GAPII re-entered. Just invoking imported function at %p", glBlitFramebuffer, s->GlesSpy::imports().glBlitFramebuffer);
        s->GlesSpy::imports().glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        GAPID_DEBUG("glBlitFramebuffer() -- done");
    }
}
EXPORT uint32_t STDCALL glCheckFramebufferStatus(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCheckFramebufferStatus(%u)", target);
    if (s->enter("glCheckFramebufferStatus")) {
        auto _result_ = s->glCheckFramebufferStatus(target);
        s->exit();
        GAPID_DEBUG("glCheckFramebufferStatus() -- done");
        return _result_;
    } else {
        GAPID_INFO("glCheckFramebufferStatus at %p: GAPII re-entered. Just invoking imported function at %p", glCheckFramebufferStatus, s->GlesSpy::imports().glCheckFramebufferStatus);
        auto _result_ = s->GlesSpy::imports().glCheckFramebufferStatus(target);
        GAPID_DEBUG("glCheckFramebufferStatus() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glClear(uint32_t mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClear(%u)", mask);
    if (s->enter("glClear")) {
        s->glClear(mask);
        s->exit();
        GAPID_DEBUG("glClear() -- done");
    } else {
        GAPID_INFO("glClear at %p: GAPII re-entered. Just invoking imported function at %p", glClear, s->GlesSpy::imports().glClear);
        s->GlesSpy::imports().glClear(mask);
        GAPID_DEBUG("glClear() -- done");
    }
}
EXPORT void STDCALL glClearBufferfi(uint32_t buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearBufferfi(%u, %" PRId32 ", %f, %" PRId32 ")", buffer, drawbuffer, depth, stencil);
    if (s->enter("glClearBufferfi")) {
        s->glClearBufferfi(buffer, drawbuffer, depth, stencil);
        s->exit();
        GAPID_DEBUG("glClearBufferfi() -- done");
    } else {
        GAPID_INFO("glClearBufferfi at %p: GAPII re-entered. Just invoking imported function at %p", glClearBufferfi, s->GlesSpy::imports().glClearBufferfi);
        s->GlesSpy::imports().glClearBufferfi(buffer, drawbuffer, depth, stencil);
        GAPID_DEBUG("glClearBufferfi() -- done");
    }
}
EXPORT void STDCALL glClearBufferfv(uint32_t buffer, GLint drawbuffer, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearBufferfv(%u, %" PRId32 ", %p)", buffer, drawbuffer, value);
    if (s->enter("glClearBufferfv")) {
        s->glClearBufferfv(buffer, drawbuffer, value);
        s->exit();
        GAPID_DEBUG("glClearBufferfv() -- done");
    } else {
        GAPID_INFO("glClearBufferfv at %p: GAPII re-entered. Just invoking imported function at %p", glClearBufferfv, s->GlesSpy::imports().glClearBufferfv);
        s->GlesSpy::imports().glClearBufferfv(buffer, drawbuffer, value);
        GAPID_DEBUG("glClearBufferfv() -- done");
    }
}
EXPORT void STDCALL glClearBufferiv(uint32_t buffer, GLint drawbuffer, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearBufferiv(%u, %" PRId32 ", %p)", buffer, drawbuffer, value);
    if (s->enter("glClearBufferiv")) {
        s->glClearBufferiv(buffer, drawbuffer, value);
        s->exit();
        GAPID_DEBUG("glClearBufferiv() -- done");
    } else {
        GAPID_INFO("glClearBufferiv at %p: GAPII re-entered. Just invoking imported function at %p", glClearBufferiv, s->GlesSpy::imports().glClearBufferiv);
        s->GlesSpy::imports().glClearBufferiv(buffer, drawbuffer, value);
        GAPID_DEBUG("glClearBufferiv() -- done");
    }
}
EXPORT void STDCALL glClearBufferuiv(uint32_t buffer, GLint drawbuffer, GLuint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearBufferuiv(%u, %" PRId32 ", %p)", buffer, drawbuffer, value);
    if (s->enter("glClearBufferuiv")) {
        s->glClearBufferuiv(buffer, drawbuffer, value);
        s->exit();
        GAPID_DEBUG("glClearBufferuiv() -- done");
    } else {
        GAPID_INFO("glClearBufferuiv at %p: GAPII re-entered. Just invoking imported function at %p", glClearBufferuiv, s->GlesSpy::imports().glClearBufferuiv);
        s->GlesSpy::imports().glClearBufferuiv(buffer, drawbuffer, value);
        GAPID_DEBUG("glClearBufferuiv() -- done");
    }
}
EXPORT void STDCALL glClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearColor(%f, %f, %f, %f)", r, g, b, a);
    if (s->enter("glClearColor")) {
        s->glClearColor(r, g, b, a);
        s->exit();
        GAPID_DEBUG("glClearColor() -- done");
    } else {
        GAPID_INFO("glClearColor at %p: GAPII re-entered. Just invoking imported function at %p", glClearColor, s->GlesSpy::imports().glClearColor);
        s->GlesSpy::imports().glClearColor(r, g, b, a);
        GAPID_DEBUG("glClearColor() -- done");
    }
}
EXPORT void STDCALL glClearDepthf(GLfloat depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthf(%f)", depth);
    if (s->enter("glClearDepthf")) {
        s->glClearDepthf(depth);
        s->exit();
        GAPID_DEBUG("glClearDepthf() -- done");
    } else {
        GAPID_INFO("glClearDepthf at %p: GAPII re-entered. Just invoking imported function at %p", glClearDepthf, s->GlesSpy::imports().glClearDepthf);
        s->GlesSpy::imports().glClearDepthf(depth);
        GAPID_DEBUG("glClearDepthf() -- done");
    }
}
EXPORT void STDCALL glClearStencil(GLint stencil) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearStencil(%" PRId32 ")", stencil);
    if (s->enter("glClearStencil")) {
        s->glClearStencil(stencil);
        s->exit();
        GAPID_DEBUG("glClearStencil() -- done");
    } else {
        GAPID_INFO("glClearStencil at %p: GAPII re-entered. Just invoking imported function at %p", glClearStencil, s->GlesSpy::imports().glClearStencil);
        s->GlesSpy::imports().glClearStencil(stencil);
        GAPID_DEBUG("glClearStencil() -- done");
    }
}
EXPORT void STDCALL glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColorMask(%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", red, green, blue, alpha);
    if (s->enter("glColorMask")) {
        s->glColorMask(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glColorMask() -- done");
    } else {
        GAPID_INFO("glColorMask at %p: GAPII re-entered. Just invoking imported function at %p", glColorMask, s->GlesSpy::imports().glColorMask);
        s->GlesSpy::imports().glColorMask(red, green, blue, alpha);
        GAPID_DEBUG("glColorMask() -- done");
    }
}
EXPORT void STDCALL glColorMaski(DrawBufferIndex index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColorMaski(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", index, r, g, b, a);
    if (s->enter("glColorMaski")) {
        s->glColorMaski(index, r, g, b, a);
        s->exit();
        GAPID_DEBUG("glColorMaski() -- done");
    } else {
        GAPID_INFO("glColorMaski at %p: GAPII re-entered. Just invoking imported function at %p", glColorMaski, s->GlesSpy::imports().glColorMaski);
        s->GlesSpy::imports().glColorMaski(index, r, g, b, a);
        GAPID_DEBUG("glColorMaski() -- done");
    }
}
EXPORT void STDCALL glDeleteFramebuffers(GLsizei count, FramebufferId* framebuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteFramebuffers(%" PRId32 ", %p)", count, framebuffers);
    if (s->enter("glDeleteFramebuffers")) {
        s->glDeleteFramebuffers(count, framebuffers);
        s->exit();
        GAPID_DEBUG("glDeleteFramebuffers() -- done");
    } else {
        GAPID_INFO("glDeleteFramebuffers at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteFramebuffers, s->GlesSpy::imports().glDeleteFramebuffers);
        s->GlesSpy::imports().glDeleteFramebuffers(count, framebuffers);
        GAPID_DEBUG("glDeleteFramebuffers() -- done");
    }
}
EXPORT void STDCALL glDeleteRenderbuffers(GLsizei count, RenderbufferId* renderbuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteRenderbuffers(%" PRId32 ", %p)", count, renderbuffers);
    if (s->enter("glDeleteRenderbuffers")) {
        s->glDeleteRenderbuffers(count, renderbuffers);
        s->exit();
        GAPID_DEBUG("glDeleteRenderbuffers() -- done");
    } else {
        GAPID_INFO("glDeleteRenderbuffers at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteRenderbuffers, s->GlesSpy::imports().glDeleteRenderbuffers);
        s->GlesSpy::imports().glDeleteRenderbuffers(count, renderbuffers);
        GAPID_DEBUG("glDeleteRenderbuffers() -- done");
    }
}
EXPORT void STDCALL glDepthMask(GLboolean enabled) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthMask(%" PRIu8 ")", enabled);
    if (s->enter("glDepthMask")) {
        s->glDepthMask(enabled);
        s->exit();
        GAPID_DEBUG("glDepthMask() -- done");
    } else {
        GAPID_INFO("glDepthMask at %p: GAPII re-entered. Just invoking imported function at %p", glDepthMask, s->GlesSpy::imports().glDepthMask);
        s->GlesSpy::imports().glDepthMask(enabled);
        GAPID_DEBUG("glDepthMask() -- done");
    }
}
EXPORT void STDCALL glDrawBuffers(GLsizei n, uint32_t* bufs) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawBuffers(%" PRId32 ", %p)", n, bufs);
    if (s->enter("glDrawBuffers")) {
        s->glDrawBuffers(n, bufs);
        s->exit();
        GAPID_DEBUG("glDrawBuffers() -- done");
    } else {
        GAPID_INFO("glDrawBuffers at %p: GAPII re-entered. Just invoking imported function at %p", glDrawBuffers, s->GlesSpy::imports().glDrawBuffers);
        s->GlesSpy::imports().glDrawBuffers(n, bufs);
        GAPID_DEBUG("glDrawBuffers() -- done");
    }
}
EXPORT void STDCALL glFramebufferParameteri(uint32_t target, uint32_t pname, GLint param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferParameteri(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glFramebufferParameteri")) {
        s->glFramebufferParameteri(target, pname, param);
        s->exit();
        GAPID_DEBUG("glFramebufferParameteri() -- done");
    } else {
        GAPID_INFO("glFramebufferParameteri at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferParameteri, s->GlesSpy::imports().glFramebufferParameteri);
        s->GlesSpy::imports().glFramebufferParameteri(target, pname, param);
        GAPID_DEBUG("glFramebufferParameteri() -- done");
    }
}
EXPORT void STDCALL glFramebufferRenderbuffer(uint32_t framebuffer_target, uint32_t framebuffer_attachment, uint32_t renderbuffer_target, RenderbufferId renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferRenderbuffer(%u, %u, %u, %" PRIu32 ")", framebuffer_target, framebuffer_attachment, renderbuffer_target, renderbuffer);
    if (s->enter("glFramebufferRenderbuffer")) {
        s->glFramebufferRenderbuffer(framebuffer_target, framebuffer_attachment, renderbuffer_target, renderbuffer);
        s->exit();
        GAPID_DEBUG("glFramebufferRenderbuffer() -- done");
    } else {
        GAPID_INFO("glFramebufferRenderbuffer at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferRenderbuffer, s->GlesSpy::imports().glFramebufferRenderbuffer);
        s->GlesSpy::imports().glFramebufferRenderbuffer(framebuffer_target, framebuffer_attachment, renderbuffer_target, renderbuffer);
        GAPID_DEBUG("glFramebufferRenderbuffer() -- done");
    }
}
EXPORT void STDCALL glFramebufferTexture(uint32_t target, uint32_t attachment, TextureId texture, GLint level) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture(%u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, texture, level);
    if (s->enter("glFramebufferTexture")) {
        s->glFramebufferTexture(target, attachment, texture, level);
        s->exit();
        GAPID_DEBUG("glFramebufferTexture() -- done");
    } else {
        GAPID_INFO("glFramebufferTexture at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture, s->GlesSpy::imports().glFramebufferTexture);
        s->GlesSpy::imports().glFramebufferTexture(target, attachment, texture, level);
        GAPID_DEBUG("glFramebufferTexture() -- done");
    }
}
EXPORT void STDCALL glFramebufferTexture2D(uint32_t framebuffer_target, uint32_t framebuffer_attachment, uint32_t texture_target, TextureId texture, GLint level) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture2D(%u, %u, %u, %" PRIu32 ", %" PRId32 ")", framebuffer_target, framebuffer_attachment, texture_target, texture, level);
    if (s->enter("glFramebufferTexture2D")) {
        s->glFramebufferTexture2D(framebuffer_target, framebuffer_attachment, texture_target, texture, level);
        s->exit();
        GAPID_DEBUG("glFramebufferTexture2D() -- done");
    } else {
        GAPID_INFO("glFramebufferTexture2D at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture2D, s->GlesSpy::imports().glFramebufferTexture2D);
        s->GlesSpy::imports().glFramebufferTexture2D(framebuffer_target, framebuffer_attachment, texture_target, texture, level);
        GAPID_DEBUG("glFramebufferTexture2D() -- done");
    }
}
EXPORT void STDCALL glFramebufferTextureLayer(uint32_t target, uint32_t attachment, TextureId texture, GLint level, GLint layer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTextureLayer(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, layer);
    if (s->enter("glFramebufferTextureLayer")) {
        s->glFramebufferTextureLayer(target, attachment, texture, level, layer);
        s->exit();
        GAPID_DEBUG("glFramebufferTextureLayer() -- done");
    } else {
        GAPID_INFO("glFramebufferTextureLayer at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTextureLayer, s->GlesSpy::imports().glFramebufferTextureLayer);
        s->GlesSpy::imports().glFramebufferTextureLayer(target, attachment, texture, level, layer);
        GAPID_DEBUG("glFramebufferTextureLayer() -- done");
    }
}
EXPORT void STDCALL glGenFramebuffers(GLsizei count, FramebufferId* framebuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenFramebuffers(%" PRId32 ", %p)", count, framebuffers);
    if (s->enter("glGenFramebuffers")) {
        s->glGenFramebuffers(count, framebuffers);
        s->exit();
        GAPID_DEBUG("glGenFramebuffers() -- done");
    } else {
        GAPID_INFO("glGenFramebuffers at %p: GAPII re-entered. Just invoking imported function at %p", glGenFramebuffers, s->GlesSpy::imports().glGenFramebuffers);
        s->GlesSpy::imports().glGenFramebuffers(count, framebuffers);
        GAPID_DEBUG("glGenFramebuffers() -- done");
    }
}
EXPORT void STDCALL glGenRenderbuffers(GLsizei count, RenderbufferId* renderbuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenRenderbuffers(%" PRId32 ", %p)", count, renderbuffers);
    if (s->enter("glGenRenderbuffers")) {
        s->glGenRenderbuffers(count, renderbuffers);
        s->exit();
        GAPID_DEBUG("glGenRenderbuffers() -- done");
    } else {
        GAPID_INFO("glGenRenderbuffers at %p: GAPII re-entered. Just invoking imported function at %p", glGenRenderbuffers, s->GlesSpy::imports().glGenRenderbuffers);
        s->GlesSpy::imports().glGenRenderbuffers(count, renderbuffers);
        GAPID_DEBUG("glGenRenderbuffers() -- done");
    }
}
EXPORT void STDCALL glGetFramebufferAttachmentParameteriv(uint32_t framebuffer_target, uint32_t attachment, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFramebufferAttachmentParameteriv(%u, %u, %u, %p)", framebuffer_target, attachment, parameter, value);
    if (s->enter("glGetFramebufferAttachmentParameteriv")) {
        s->glGetFramebufferAttachmentParameteriv(framebuffer_target, attachment, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetFramebufferAttachmentParameteriv() -- done");
    } else {
        GAPID_INFO("glGetFramebufferAttachmentParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetFramebufferAttachmentParameteriv, s->GlesSpy::imports().glGetFramebufferAttachmentParameteriv);
        s->GlesSpy::imports().glGetFramebufferAttachmentParameteriv(framebuffer_target, attachment, parameter, value);
        GAPID_DEBUG("glGetFramebufferAttachmentParameteriv() -- done");
    }
}
EXPORT void STDCALL glGetFramebufferParameteriv(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFramebufferParameteriv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetFramebufferParameteriv")) {
        s->glGetFramebufferParameteriv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetFramebufferParameteriv() -- done");
    } else {
        GAPID_INFO("glGetFramebufferParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetFramebufferParameteriv, s->GlesSpy::imports().glGetFramebufferParameteriv);
        s->GlesSpy::imports().glGetFramebufferParameteriv(target, pname, params);
        GAPID_DEBUG("glGetFramebufferParameteriv() -- done");
    }
}
EXPORT void STDCALL glGetRenderbufferParameteriv(uint32_t target, uint32_t parameter, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetRenderbufferParameteriv(%u, %u, %p)", target, parameter, values);
    if (s->enter("glGetRenderbufferParameteriv")) {
        s->glGetRenderbufferParameteriv(target, parameter, values);
        s->exit();
        GAPID_DEBUG("glGetRenderbufferParameteriv() -- done");
    } else {
        GAPID_INFO("glGetRenderbufferParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetRenderbufferParameteriv, s->GlesSpy::imports().glGetRenderbufferParameteriv);
        s->GlesSpy::imports().glGetRenderbufferParameteriv(target, parameter, values);
        GAPID_DEBUG("glGetRenderbufferParameteriv() -- done");
    }
}
EXPORT void STDCALL glInvalidateFramebuffer(uint32_t target, GLsizei count, uint32_t* attachments) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glInvalidateFramebuffer(%u, %" PRId32 ", %p)", target, count, attachments);
    if (s->enter("glInvalidateFramebuffer")) {
        s->glInvalidateFramebuffer(target, count, attachments);
        s->exit();
        GAPID_DEBUG("glInvalidateFramebuffer() -- done");
    } else {
        GAPID_INFO("glInvalidateFramebuffer at %p: GAPII re-entered. Just invoking imported function at %p", glInvalidateFramebuffer, s->GlesSpy::imports().glInvalidateFramebuffer);
        s->GlesSpy::imports().glInvalidateFramebuffer(target, count, attachments);
        GAPID_DEBUG("glInvalidateFramebuffer() -- done");
    }
}
EXPORT void STDCALL glInvalidateSubFramebuffer(uint32_t target, GLsizei numAttachments, uint32_t* attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glInvalidateSubFramebuffer(%u, %" PRId32 ", %p, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, numAttachments, attachments, x, y, width, height);
    if (s->enter("glInvalidateSubFramebuffer")) {
        s->glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
        s->exit();
        GAPID_DEBUG("glInvalidateSubFramebuffer() -- done");
    } else {
        GAPID_INFO("glInvalidateSubFramebuffer at %p: GAPII re-entered. Just invoking imported function at %p", glInvalidateSubFramebuffer, s->GlesSpy::imports().glInvalidateSubFramebuffer);
        s->GlesSpy::imports().glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
        GAPID_DEBUG("glInvalidateSubFramebuffer() -- done");
    }
}
EXPORT GLboolean STDCALL glIsFramebuffer(FramebufferId framebuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsFramebuffer(%" PRIu32 ")", framebuffer);
    if (s->enter("glIsFramebuffer")) {
        auto _result_ = s->glIsFramebuffer(framebuffer);
        s->exit();
        GAPID_DEBUG("glIsFramebuffer() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsFramebuffer at %p: GAPII re-entered. Just invoking imported function at %p", glIsFramebuffer, s->GlesSpy::imports().glIsFramebuffer);
        auto _result_ = s->GlesSpy::imports().glIsFramebuffer(framebuffer);
        GAPID_DEBUG("glIsFramebuffer() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsRenderbuffer(RenderbufferId renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsRenderbuffer(%" PRIu32 ")", renderbuffer);
    if (s->enter("glIsRenderbuffer")) {
        auto _result_ = s->glIsRenderbuffer(renderbuffer);
        s->exit();
        GAPID_DEBUG("glIsRenderbuffer() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsRenderbuffer at %p: GAPII re-entered. Just invoking imported function at %p", glIsRenderbuffer, s->GlesSpy::imports().glIsRenderbuffer);
        auto _result_ = s->GlesSpy::imports().glIsRenderbuffer(renderbuffer);
        GAPID_DEBUG("glIsRenderbuffer() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glReadBuffer(uint32_t src) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadBuffer(%u)", src);
    if (s->enter("glReadBuffer")) {
        s->glReadBuffer(src);
        s->exit();
        GAPID_DEBUG("glReadBuffer() -- done");
    } else {
        GAPID_INFO("glReadBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glReadBuffer, s->GlesSpy::imports().glReadBuffer);
        s->GlesSpy::imports().glReadBuffer(src);
        GAPID_DEBUG("glReadBuffer() -- done");
    }
}
EXPORT void STDCALL glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadPixels(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", x, y, width, height, format, type, data);
    if (s->enter("glReadPixels")) {
        s->glReadPixels(x, y, width, height, format, type, data);
        s->exit();
        GAPID_DEBUG("glReadPixels() -- done");
    } else {
        GAPID_INFO("glReadPixels at %p: GAPII re-entered. Just invoking imported function at %p", glReadPixels, s->GlesSpy::imports().glReadPixels);
        s->GlesSpy::imports().glReadPixels(x, y, width, height, format, type, data);
        GAPID_DEBUG("glReadPixels() -- done");
    }
}
EXPORT void STDCALL glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, uint32_t format, uint32_t type, GLsizei bufSize, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadnPixels(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %" PRId32 ", %p)", x, y, width, height, format, type, bufSize, data);
    if (s->enter("glReadnPixels")) {
        s->glReadnPixels(x, y, width, height, format, type, bufSize, data);
        s->exit();
        GAPID_DEBUG("glReadnPixels() -- done");
    } else {
        GAPID_INFO("glReadnPixels at %p: GAPII re-entered. Just invoking imported function at %p", glReadnPixels, s->GlesSpy::imports().glReadnPixels);
        s->GlesSpy::imports().glReadnPixels(x, y, width, height, format, type, bufSize, data);
        GAPID_DEBUG("glReadnPixels() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorage(uint32_t target, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorage(%u, %u, %" PRId32 ", %" PRId32 ")", target, internalformat, width, height);
    if (s->enter("glRenderbufferStorage")) {
        s->glRenderbufferStorage(target, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorage() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorage at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorage, s->GlesSpy::imports().glRenderbufferStorage);
        s->GlesSpy::imports().glRenderbufferStorage(target, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorage() -- done");
    }
}
EXPORT void STDCALL glRenderbufferStorageMultisample(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
    if (s->enter("glRenderbufferStorageMultisample")) {
        s->glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageMultisample() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageMultisample at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageMultisample, s->GlesSpy::imports().glRenderbufferStorageMultisample);
        s->GlesSpy::imports().glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageMultisample() -- done");
    }
}
EXPORT void STDCALL glStencilMask(GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilMask(%" PRIu32 ")", mask);
    if (s->enter("glStencilMask")) {
        s->glStencilMask(mask);
        s->exit();
        GAPID_DEBUG("glStencilMask() -- done");
    } else {
        GAPID_INFO("glStencilMask at %p: GAPII re-entered. Just invoking imported function at %p", glStencilMask, s->GlesSpy::imports().glStencilMask);
        s->GlesSpy::imports().glStencilMask(mask);
        GAPID_DEBUG("glStencilMask() -- done");
    }
}
EXPORT void STDCALL glStencilMaskSeparate(uint32_t face, GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilMaskSeparate(%u, %" PRIu32 ")", face, mask);
    if (s->enter("glStencilMaskSeparate")) {
        s->glStencilMaskSeparate(face, mask);
        s->exit();
        GAPID_DEBUG("glStencilMaskSeparate() -- done");
    } else {
        GAPID_INFO("glStencilMaskSeparate at %p: GAPII re-entered. Just invoking imported function at %p", glStencilMaskSeparate, s->GlesSpy::imports().glStencilMaskSeparate);
        s->GlesSpy::imports().glStencilMaskSeparate(face, mask);
        GAPID_DEBUG("glStencilMaskSeparate() -- done");
    }
}
EXPORT void STDCALL glDisable(uint32_t capability) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisable(%u)", capability);
    if (s->enter("glDisable")) {
        s->glDisable(capability);
        s->exit();
        GAPID_DEBUG("glDisable() -- done");
    } else {
        GAPID_INFO("glDisable at %p: GAPII re-entered. Just invoking imported function at %p", glDisable, s->GlesSpy::imports().glDisable);
        s->GlesSpy::imports().glDisable(capability);
        GAPID_DEBUG("glDisable() -- done");
    }
}
EXPORT void STDCALL glDisablei(uint32_t capability, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisablei(%u, %" PRIu32 ")", capability, index);
    if (s->enter("glDisablei")) {
        s->glDisablei(capability, index);
        s->exit();
        GAPID_DEBUG("glDisablei() -- done");
    } else {
        GAPID_INFO("glDisablei at %p: GAPII re-entered. Just invoking imported function at %p", glDisablei, s->GlesSpy::imports().glDisablei);
        s->GlesSpy::imports().glDisablei(capability, index);
        GAPID_DEBUG("glDisablei() -- done");
    }
}
EXPORT void STDCALL glEnable(uint32_t capability) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnable(%u)", capability);
    if (s->enter("glEnable")) {
        s->glEnable(capability);
        s->exit();
        GAPID_DEBUG("glEnable() -- done");
    } else {
        GAPID_INFO("glEnable at %p: GAPII re-entered. Just invoking imported function at %p", glEnable, s->GlesSpy::imports().glEnable);
        s->GlesSpy::imports().glEnable(capability);
        GAPID_DEBUG("glEnable() -- done");
    }
}
EXPORT void STDCALL glEnablei(uint32_t capability, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnablei(%u, %" PRIu32 ")", capability, index);
    if (s->enter("glEnablei")) {
        s->glEnablei(capability, index);
        s->exit();
        GAPID_DEBUG("glEnablei() -- done");
    } else {
        GAPID_INFO("glEnablei at %p: GAPII re-entered. Just invoking imported function at %p", glEnablei, s->GlesSpy::imports().glEnablei);
        s->GlesSpy::imports().glEnablei(capability, index);
        GAPID_DEBUG("glEnablei() -- done");
    }
}
EXPORT void STDCALL glFinish() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFinish()");
    if (s->enter("glFinish")) {
        s->glFinish();
        s->exit();
        GAPID_DEBUG("glFinish() -- done");
    } else {
        GAPID_INFO("glFinish at %p: GAPII re-entered. Just invoking imported function at %p", glFinish, s->GlesSpy::imports().glFinish);
        s->GlesSpy::imports().glFinish();
        GAPID_DEBUG("glFinish() -- done");
    }
}
EXPORT void STDCALL glFlush() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFlush()");
    if (s->enter("glFlush")) {
        s->glFlush();
        s->exit();
        GAPID_DEBUG("glFlush() -- done");
    } else {
        GAPID_INFO("glFlush at %p: GAPII re-entered. Just invoking imported function at %p", glFlush, s->GlesSpy::imports().glFlush);
        s->GlesSpy::imports().glFlush();
        GAPID_DEBUG("glFlush() -- done");
    }
}
EXPORT void STDCALL glFlushMappedBufferRange(uint32_t target, GLintptr offset, GLsizeiptr length) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFlushMappedBufferRange(%u, %" PRId32 ", %" PRId32 ")", target, offset, length);
    if (s->enter("glFlushMappedBufferRange")) {
        s->glFlushMappedBufferRange(target, offset, length);
        s->exit();
        GAPID_DEBUG("glFlushMappedBufferRange() -- done");
    } else {
        GAPID_INFO("glFlushMappedBufferRange at %p: GAPII re-entered. Just invoking imported function at %p", glFlushMappedBufferRange, s->GlesSpy::imports().glFlushMappedBufferRange);
        s->GlesSpy::imports().glFlushMappedBufferRange(target, offset, length);
        GAPID_DEBUG("glFlushMappedBufferRange() -- done");
    }
}
EXPORT uint32_t STDCALL glGetError() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetError()");
    if (s->enter("glGetError")) {
        auto _result_ = s->glGetError();
        s->exit();
        GAPID_DEBUG("glGetError() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetError at %p: GAPII re-entered. Just invoking imported function at %p", glGetError, s->GlesSpy::imports().glGetError);
        auto _result_ = s->GlesSpy::imports().glGetError();
        GAPID_DEBUG("glGetError() -- done");
        return _result_;
    }
}
EXPORT uint32_t STDCALL glGetGraphicsResetStatus() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetGraphicsResetStatus()");
    if (s->enter("glGetGraphicsResetStatus")) {
        auto _result_ = s->glGetGraphicsResetStatus();
        s->exit();
        GAPID_DEBUG("glGetGraphicsResetStatus() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetGraphicsResetStatus at %p: GAPII re-entered. Just invoking imported function at %p", glGetGraphicsResetStatus, s->GlesSpy::imports().glGetGraphicsResetStatus);
        auto _result_ = s->GlesSpy::imports().glGetGraphicsResetStatus();
        GAPID_DEBUG("glGetGraphicsResetStatus() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glHint(uint32_t target, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glHint(%u, %u)", target, mode);
    if (s->enter("glHint")) {
        s->glHint(target, mode);
        s->exit();
        GAPID_DEBUG("glHint() -- done");
    } else {
        GAPID_INFO("glHint at %p: GAPII re-entered. Just invoking imported function at %p", glHint, s->GlesSpy::imports().glHint);
        s->GlesSpy::imports().glHint(target, mode);
        GAPID_DEBUG("glHint() -- done");
    }
}
EXPORT void STDCALL glActiveShaderProgram(PipelineId pipeline, ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glActiveShaderProgram(%" PRIu32 ", %" PRIu32 ")", pipeline, program);
    if (s->enter("glActiveShaderProgram")) {
        s->glActiveShaderProgram(pipeline, program);
        s->exit();
        GAPID_DEBUG("glActiveShaderProgram() -- done");
    } else {
        GAPID_INFO("glActiveShaderProgram at %p: GAPII re-entered. Just invoking imported function at %p", glActiveShaderProgram, s->GlesSpy::imports().glActiveShaderProgram);
        s->GlesSpy::imports().glActiveShaderProgram(pipeline, program);
        GAPID_DEBUG("glActiveShaderProgram() -- done");
    }
}
EXPORT void STDCALL glAttachShader(ProgramId program, ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glAttachShader(%" PRIu32 ", %" PRIu32 ")", program, shader);
    if (s->enter("glAttachShader")) {
        s->glAttachShader(program, shader);
        s->exit();
        GAPID_DEBUG("glAttachShader() -- done");
    } else {
        GAPID_INFO("glAttachShader at %p: GAPII re-entered. Just invoking imported function at %p", glAttachShader, s->GlesSpy::imports().glAttachShader);
        s->GlesSpy::imports().glAttachShader(program, shader);
        GAPID_DEBUG("glAttachShader() -- done");
    }
}
EXPORT void STDCALL glBindAttribLocation(ProgramId program, AttributeLocation location, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindAttribLocation(%" PRIu32 ", %" PRIu32 ", %s)", program, location, name);
    if (s->enter("glBindAttribLocation")) {
        s->glBindAttribLocation(program, location, name);
        s->exit();
        GAPID_DEBUG("glBindAttribLocation() -- done");
    } else {
        GAPID_INFO("glBindAttribLocation at %p: GAPII re-entered. Just invoking imported function at %p", glBindAttribLocation, s->GlesSpy::imports().glBindAttribLocation);
        s->GlesSpy::imports().glBindAttribLocation(program, location, name);
        GAPID_DEBUG("glBindAttribLocation() -- done");
    }
}
EXPORT void STDCALL glBindProgramPipeline(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindProgramPipeline(%" PRIu32 ")", pipeline);
    if (s->enter("glBindProgramPipeline")) {
        s->glBindProgramPipeline(pipeline);
        s->exit();
        GAPID_DEBUG("glBindProgramPipeline() -- done");
    } else {
        GAPID_INFO("glBindProgramPipeline at %p: GAPII re-entered. Just invoking imported function at %p", glBindProgramPipeline, s->GlesSpy::imports().glBindProgramPipeline);
        s->GlesSpy::imports().glBindProgramPipeline(pipeline);
        GAPID_DEBUG("glBindProgramPipeline() -- done");
    }
}
EXPORT void STDCALL glCompileShader(ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompileShader(%" PRIu32 ")", shader);
    if (s->enter("glCompileShader")) {
        s->glCompileShader(shader);
        s->exit();
        GAPID_DEBUG("glCompileShader() -- done");
    } else {
        GAPID_INFO("glCompileShader at %p: GAPII re-entered. Just invoking imported function at %p", glCompileShader, s->GlesSpy::imports().glCompileShader);
        s->GlesSpy::imports().glCompileShader(shader);
        GAPID_DEBUG("glCompileShader() -- done");
    }
}
EXPORT ProgramId STDCALL glCreateProgram() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreateProgram()");
    if (s->enter("glCreateProgram")) {
        auto _result_ = s->glCreateProgram();
        s->exit();
        GAPID_DEBUG("glCreateProgram() -- done");
        return _result_;
    } else {
        GAPID_INFO("glCreateProgram at %p: GAPII re-entered. Just invoking imported function at %p", glCreateProgram, s->GlesSpy::imports().glCreateProgram);
        auto _result_ = s->GlesSpy::imports().glCreateProgram();
        GAPID_DEBUG("glCreateProgram() -- done");
        return _result_;
    }
}
EXPORT ShaderId STDCALL glCreateShader(uint32_t type) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreateShader(%u)", type);
    if (s->enter("glCreateShader")) {
        auto _result_ = s->glCreateShader(type);
        s->exit();
        GAPID_DEBUG("glCreateShader() -- done");
        return _result_;
    } else {
        GAPID_INFO("glCreateShader at %p: GAPII re-entered. Just invoking imported function at %p", glCreateShader, s->GlesSpy::imports().glCreateShader);
        auto _result_ = s->GlesSpy::imports().glCreateShader(type);
        GAPID_DEBUG("glCreateShader() -- done");
        return _result_;
    }
}
EXPORT ProgramId STDCALL glCreateShaderProgramv(uint32_t type, GLsizei count, GLchar** strings) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreateShaderProgramv(%u, %" PRId32 ", %p)", type, count, strings);
    if (s->enter("glCreateShaderProgramv")) {
        auto _result_ = s->glCreateShaderProgramv(type, count, strings);
        s->exit();
        GAPID_DEBUG("glCreateShaderProgramv() -- done");
        return _result_;
    } else {
        GAPID_INFO("glCreateShaderProgramv at %p: GAPII re-entered. Just invoking imported function at %p", glCreateShaderProgramv, s->GlesSpy::imports().glCreateShaderProgramv);
        auto _result_ = s->GlesSpy::imports().glCreateShaderProgramv(type, count, strings);
        GAPID_DEBUG("glCreateShaderProgramv() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glDeleteProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteProgram(%" PRIu32 ")", program);
    if (s->enter("glDeleteProgram")) {
        s->glDeleteProgram(program);
        s->exit();
        GAPID_DEBUG("glDeleteProgram() -- done");
    } else {
        GAPID_INFO("glDeleteProgram at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteProgram, s->GlesSpy::imports().glDeleteProgram);
        s->GlesSpy::imports().glDeleteProgram(program);
        GAPID_DEBUG("glDeleteProgram() -- done");
    }
}
EXPORT void STDCALL glDeleteProgramPipelines(GLsizei n, PipelineId* pipelines) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteProgramPipelines(%" PRId32 ", %p)", n, pipelines);
    if (s->enter("glDeleteProgramPipelines")) {
        s->glDeleteProgramPipelines(n, pipelines);
        s->exit();
        GAPID_DEBUG("glDeleteProgramPipelines() -- done");
    } else {
        GAPID_INFO("glDeleteProgramPipelines at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteProgramPipelines, s->GlesSpy::imports().glDeleteProgramPipelines);
        s->GlesSpy::imports().glDeleteProgramPipelines(n, pipelines);
        GAPID_DEBUG("glDeleteProgramPipelines() -- done");
    }
}
EXPORT void STDCALL glDeleteShader(ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteShader(%" PRIu32 ")", shader);
    if (s->enter("glDeleteShader")) {
        s->glDeleteShader(shader);
        s->exit();
        GAPID_DEBUG("glDeleteShader() -- done");
    } else {
        GAPID_INFO("glDeleteShader at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteShader, s->GlesSpy::imports().glDeleteShader);
        s->GlesSpy::imports().glDeleteShader(shader);
        GAPID_DEBUG("glDeleteShader() -- done");
    }
}
EXPORT void STDCALL glDetachShader(ProgramId program, ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDetachShader(%" PRIu32 ", %" PRIu32 ")", program, shader);
    if (s->enter("glDetachShader")) {
        s->glDetachShader(program, shader);
        s->exit();
        GAPID_DEBUG("glDetachShader() -- done");
    } else {
        GAPID_INFO("glDetachShader at %p: GAPII re-entered. Just invoking imported function at %p", glDetachShader, s->GlesSpy::imports().glDetachShader);
        s->GlesSpy::imports().glDetachShader(program, shader);
        GAPID_DEBUG("glDetachShader() -- done");
    }
}
EXPORT void STDCALL glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDispatchCompute(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", num_groups_x, num_groups_y, num_groups_z);
    if (s->enter("glDispatchCompute")) {
        s->glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
        s->exit();
        GAPID_DEBUG("glDispatchCompute() -- done");
    } else {
        GAPID_INFO("glDispatchCompute at %p: GAPII re-entered. Just invoking imported function at %p", glDispatchCompute, s->GlesSpy::imports().glDispatchCompute);
        s->GlesSpy::imports().glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
        GAPID_DEBUG("glDispatchCompute() -- done");
    }
}
EXPORT void STDCALL glDispatchComputeIndirect(GLintptr indirect) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDispatchComputeIndirect(%" PRId32 ")", indirect);
    if (s->enter("glDispatchComputeIndirect")) {
        s->glDispatchComputeIndirect(indirect);
        s->exit();
        GAPID_DEBUG("glDispatchComputeIndirect() -- done");
    } else {
        GAPID_INFO("glDispatchComputeIndirect at %p: GAPII re-entered. Just invoking imported function at %p", glDispatchComputeIndirect, s->GlesSpy::imports().glDispatchComputeIndirect);
        s->GlesSpy::imports().glDispatchComputeIndirect(indirect);
        GAPID_DEBUG("glDispatchComputeIndirect() -- done");
    }
}
EXPORT void STDCALL glGenProgramPipelines(GLsizei n, PipelineId* pipelines) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenProgramPipelines(%" PRId32 ", %p)", n, pipelines);
    if (s->enter("glGenProgramPipelines")) {
        s->glGenProgramPipelines(n, pipelines);
        s->exit();
        GAPID_DEBUG("glGenProgramPipelines() -- done");
    } else {
        GAPID_INFO("glGenProgramPipelines at %p: GAPII re-entered. Just invoking imported function at %p", glGenProgramPipelines, s->GlesSpy::imports().glGenProgramPipelines);
        s->GlesSpy::imports().glGenProgramPipelines(n, pipelines);
        GAPID_DEBUG("glGenProgramPipelines() -- done");
    }
}
EXPORT void STDCALL glGetActiveAttrib(ProgramId program, AttributeIndex index, GLsizei buffer_size, GLsizei* buffer_bytes_written, GLint* vector_count, uint32_t* type, GLchar* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetActiveAttrib(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)", program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
    if (s->enter("glGetActiveAttrib")) {
        s->glGetActiveAttrib(program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
        s->exit();
        GAPID_DEBUG("glGetActiveAttrib() -- done");
    } else {
        GAPID_INFO("glGetActiveAttrib at %p: GAPII re-entered. Just invoking imported function at %p", glGetActiveAttrib, s->GlesSpy::imports().glGetActiveAttrib);
        s->GlesSpy::imports().glGetActiveAttrib(program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
        GAPID_DEBUG("glGetActiveAttrib() -- done");
    }
}
EXPORT void STDCALL glGetActiveUniform(ProgramId program, UniformIndex index, GLsizei buffer_size, GLsizei* buffer_bytes_written, GLint* vector_count, uint32_t* type, GLchar* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetActiveUniform(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)", program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
    if (s->enter("glGetActiveUniform")) {
        s->glGetActiveUniform(program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
        s->exit();
        GAPID_DEBUG("glGetActiveUniform() -- done");
    } else {
        GAPID_INFO("glGetActiveUniform at %p: GAPII re-entered. Just invoking imported function at %p", glGetActiveUniform, s->GlesSpy::imports().glGetActiveUniform);
        s->GlesSpy::imports().glGetActiveUniform(program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
        GAPID_DEBUG("glGetActiveUniform() -- done");
    }
}
EXPORT void STDCALL glGetActiveUniformBlockName(ProgramId program, UniformBlockId uniform_block_index, GLsizei buffer_size, GLsizei* buffer_bytes_written, GLchar* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetActiveUniformBlockName(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)", program, uniform_block_index, buffer_size, buffer_bytes_written, name);
    if (s->enter("glGetActiveUniformBlockName")) {
        s->glGetActiveUniformBlockName(program, uniform_block_index, buffer_size, buffer_bytes_written, name);
        s->exit();
        GAPID_DEBUG("glGetActiveUniformBlockName() -- done");
    } else {
        GAPID_INFO("glGetActiveUniformBlockName at %p: GAPII re-entered. Just invoking imported function at %p", glGetActiveUniformBlockName, s->GlesSpy::imports().glGetActiveUniformBlockName);
        s->GlesSpy::imports().glGetActiveUniformBlockName(program, uniform_block_index, buffer_size, buffer_bytes_written, name);
        GAPID_DEBUG("glGetActiveUniformBlockName() -- done");
    }
}
EXPORT void STDCALL glGetActiveUniformBlockiv(ProgramId program, UniformBlockId uniform_block_index, uint32_t parameter_name, GLint* parameters) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetActiveUniformBlockiv(%" PRIu32 ", %" PRIu32 ", %u, %p)", program, uniform_block_index, parameter_name, parameters);
    if (s->enter("glGetActiveUniformBlockiv")) {
        s->glGetActiveUniformBlockiv(program, uniform_block_index, parameter_name, parameters);
        s->exit();
        GAPID_DEBUG("glGetActiveUniformBlockiv() -- done");
    } else {
        GAPID_INFO("glGetActiveUniformBlockiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetActiveUniformBlockiv, s->GlesSpy::imports().glGetActiveUniformBlockiv);
        s->GlesSpy::imports().glGetActiveUniformBlockiv(program, uniform_block_index, parameter_name, parameters);
        GAPID_DEBUG("glGetActiveUniformBlockiv() -- done");
    }
}
EXPORT void STDCALL glGetActiveUniformsiv(ProgramId program, GLsizei uniform_count, UniformIndex* uniform_indices, uint32_t parameter_name, GLint* parameters) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetActiveUniformsiv(%" PRIu32 ", %" PRId32 ", %p, %u, %p)", program, uniform_count, uniform_indices, parameter_name, parameters);
    if (s->enter("glGetActiveUniformsiv")) {
        s->glGetActiveUniformsiv(program, uniform_count, uniform_indices, parameter_name, parameters);
        s->exit();
        GAPID_DEBUG("glGetActiveUniformsiv() -- done");
    } else {
        GAPID_INFO("glGetActiveUniformsiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetActiveUniformsiv, s->GlesSpy::imports().glGetActiveUniformsiv);
        s->GlesSpy::imports().glGetActiveUniformsiv(program, uniform_count, uniform_indices, parameter_name, parameters);
        GAPID_DEBUG("glGetActiveUniformsiv() -- done");
    }
}
EXPORT void STDCALL glGetAttachedShaders(ProgramId program, GLsizei buffer_length, GLsizei* shaders_length_written, ShaderId* shaders) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetAttachedShaders(%" PRIu32 ", %" PRId32 ", %p, %p)", program, buffer_length, shaders_length_written, shaders);
    if (s->enter("glGetAttachedShaders")) {
        s->glGetAttachedShaders(program, buffer_length, shaders_length_written, shaders);
        s->exit();
        GAPID_DEBUG("glGetAttachedShaders() -- done");
    } else {
        GAPID_INFO("glGetAttachedShaders at %p: GAPII re-entered. Just invoking imported function at %p", glGetAttachedShaders, s->GlesSpy::imports().glGetAttachedShaders);
        s->GlesSpy::imports().glGetAttachedShaders(program, buffer_length, shaders_length_written, shaders);
        GAPID_DEBUG("glGetAttachedShaders() -- done");
    }
}
EXPORT GLint STDCALL glGetAttribLocation(ProgramId program, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetAttribLocation(%" PRIu32 ", %s)", program, name);
    if (s->enter("glGetAttribLocation")) {
        auto _result_ = s->glGetAttribLocation(program, name);
        s->exit();
        GAPID_DEBUG("glGetAttribLocation() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetAttribLocation at %p: GAPII re-entered. Just invoking imported function at %p", glGetAttribLocation, s->GlesSpy::imports().glGetAttribLocation);
        auto _result_ = s->GlesSpy::imports().glGetAttribLocation(program, name);
        GAPID_DEBUG("glGetAttribLocation() -- done");
        return _result_;
    }
}
EXPORT GLint STDCALL glGetFragDataLocation(ProgramId program, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFragDataLocation(%" PRIu32 ", %s)", program, name);
    if (s->enter("glGetFragDataLocation")) {
        auto _result_ = s->glGetFragDataLocation(program, name);
        s->exit();
        GAPID_DEBUG("glGetFragDataLocation() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetFragDataLocation at %p: GAPII re-entered. Just invoking imported function at %p", glGetFragDataLocation, s->GlesSpy::imports().glGetFragDataLocation);
        auto _result_ = s->GlesSpy::imports().glGetFragDataLocation(program, name);
        GAPID_DEBUG("glGetFragDataLocation() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetProgramBinary(ProgramId program, GLsizei bufSize, GLsizei* length, uint32_t* binaryFormat, void* binary) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramBinary(%" PRIu32 ", %" PRId32 ", %p, %p, %p)", program, bufSize, length, binaryFormat, binary);
    if (s->enter("glGetProgramBinary")) {
        s->glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
        s->exit();
        GAPID_DEBUG("glGetProgramBinary() -- done");
    } else {
        GAPID_INFO("glGetProgramBinary at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramBinary, s->GlesSpy::imports().glGetProgramBinary);
        s->GlesSpy::imports().glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
        GAPID_DEBUG("glGetProgramBinary() -- done");
    }
}
EXPORT void STDCALL glGetProgramInfoLog(ProgramId program, GLsizei buffer_length, GLsizei* string_length_written, GLchar* info) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)", program, buffer_length, string_length_written, info);
    if (s->enter("glGetProgramInfoLog")) {
        s->glGetProgramInfoLog(program, buffer_length, string_length_written, info);
        s->exit();
        GAPID_DEBUG("glGetProgramInfoLog() -- done");
    } else {
        GAPID_INFO("glGetProgramInfoLog at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramInfoLog, s->GlesSpy::imports().glGetProgramInfoLog);
        s->GlesSpy::imports().glGetProgramInfoLog(program, buffer_length, string_length_written, info);
        GAPID_DEBUG("glGetProgramInfoLog() -- done");
    }
}
EXPORT void STDCALL glGetProgramInterfaceiv(ProgramId program, uint32_t programInterface, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramInterfaceiv(%" PRIu32 ", %u, %u, %p)", program, programInterface, pname, params);
    if (s->enter("glGetProgramInterfaceiv")) {
        s->glGetProgramInterfaceiv(program, programInterface, pname, params);
        s->exit();
        GAPID_DEBUG("glGetProgramInterfaceiv() -- done");
    } else {
        GAPID_INFO("glGetProgramInterfaceiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramInterfaceiv, s->GlesSpy::imports().glGetProgramInterfaceiv);
        s->GlesSpy::imports().glGetProgramInterfaceiv(program, programInterface, pname, params);
        GAPID_DEBUG("glGetProgramInterfaceiv() -- done");
    }
}
EXPORT void STDCALL glGetProgramPipelineInfoLog(PipelineId pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramPipelineInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)", pipeline, bufSize, length, infoLog);
    if (s->enter("glGetProgramPipelineInfoLog")) {
        s->glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
        s->exit();
        GAPID_DEBUG("glGetProgramPipelineInfoLog() -- done");
    } else {
        GAPID_INFO("glGetProgramPipelineInfoLog at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramPipelineInfoLog, s->GlesSpy::imports().glGetProgramPipelineInfoLog);
        s->GlesSpy::imports().glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
        GAPID_DEBUG("glGetProgramPipelineInfoLog() -- done");
    }
}
EXPORT void STDCALL glGetProgramPipelineiv(PipelineId pipeline, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramPipelineiv(%" PRIu32 ", %u, %p)", pipeline, pname, params);
    if (s->enter("glGetProgramPipelineiv")) {
        s->glGetProgramPipelineiv(pipeline, pname, params);
        s->exit();
        GAPID_DEBUG("glGetProgramPipelineiv() -- done");
    } else {
        GAPID_INFO("glGetProgramPipelineiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramPipelineiv, s->GlesSpy::imports().glGetProgramPipelineiv);
        s->GlesSpy::imports().glGetProgramPipelineiv(pipeline, pname, params);
        GAPID_DEBUG("glGetProgramPipelineiv() -- done");
    }
}
EXPORT GLuint STDCALL glGetProgramResourceIndex(ProgramId program, uint32_t programInterface, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramResourceIndex(%" PRIu32 ", %u, %s)", program, programInterface, name);
    if (s->enter("glGetProgramResourceIndex")) {
        auto _result_ = s->glGetProgramResourceIndex(program, programInterface, name);
        s->exit();
        GAPID_DEBUG("glGetProgramResourceIndex() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetProgramResourceIndex at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramResourceIndex, s->GlesSpy::imports().glGetProgramResourceIndex);
        auto _result_ = s->GlesSpy::imports().glGetProgramResourceIndex(program, programInterface, name);
        GAPID_DEBUG("glGetProgramResourceIndex() -- done");
        return _result_;
    }
}
EXPORT GLint STDCALL glGetProgramResourceLocation(ProgramId program, uint32_t programInterface, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramResourceLocation(%" PRIu32 ", %u, %s)", program, programInterface, name);
    if (s->enter("glGetProgramResourceLocation")) {
        auto _result_ = s->glGetProgramResourceLocation(program, programInterface, name);
        s->exit();
        GAPID_DEBUG("glGetProgramResourceLocation() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetProgramResourceLocation at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramResourceLocation, s->GlesSpy::imports().glGetProgramResourceLocation);
        auto _result_ = s->GlesSpy::imports().glGetProgramResourceLocation(program, programInterface, name);
        GAPID_DEBUG("glGetProgramResourceLocation() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetProgramResourceName(ProgramId program, uint32_t programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramResourceName(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %p)", program, programInterface, index, bufSize, length, name);
    if (s->enter("glGetProgramResourceName")) {
        s->glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
        s->exit();
        GAPID_DEBUG("glGetProgramResourceName() -- done");
    } else {
        GAPID_INFO("glGetProgramResourceName at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramResourceName, s->GlesSpy::imports().glGetProgramResourceName);
        s->GlesSpy::imports().glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
        GAPID_DEBUG("glGetProgramResourceName() -- done");
    }
}
EXPORT void STDCALL glGetProgramResourceiv(ProgramId program, uint32_t programInterface, GLuint index, GLsizei propCount, uint32_t* props, GLsizei bufSize, GLsizei* length, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramResourceiv(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %p, %p)", program, programInterface, index, propCount, props, bufSize, length, params);
    if (s->enter("glGetProgramResourceiv")) {
        s->glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
        s->exit();
        GAPID_DEBUG("glGetProgramResourceiv() -- done");
    } else {
        GAPID_INFO("glGetProgramResourceiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramResourceiv, s->GlesSpy::imports().glGetProgramResourceiv);
        s->GlesSpy::imports().glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
        GAPID_DEBUG("glGetProgramResourceiv() -- done");
    }
}
EXPORT void STDCALL glGetProgramiv(ProgramId program, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetProgramiv(%" PRIu32 ", %u, %p)", program, parameter, value);
    if (s->enter("glGetProgramiv")) {
        s->glGetProgramiv(program, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetProgramiv() -- done");
    } else {
        GAPID_INFO("glGetProgramiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetProgramiv, s->GlesSpy::imports().glGetProgramiv);
        s->GlesSpy::imports().glGetProgramiv(program, parameter, value);
        GAPID_DEBUG("glGetProgramiv() -- done");
    }
}
EXPORT void STDCALL glGetShaderInfoLog(ShaderId shader, GLsizei buffer_length, GLsizei* string_length_written, GLchar* info) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetShaderInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, buffer_length, string_length_written, info);
    if (s->enter("glGetShaderInfoLog")) {
        s->glGetShaderInfoLog(shader, buffer_length, string_length_written, info);
        s->exit();
        GAPID_DEBUG("glGetShaderInfoLog() -- done");
    } else {
        GAPID_INFO("glGetShaderInfoLog at %p: GAPII re-entered. Just invoking imported function at %p", glGetShaderInfoLog, s->GlesSpy::imports().glGetShaderInfoLog);
        s->GlesSpy::imports().glGetShaderInfoLog(shader, buffer_length, string_length_written, info);
        GAPID_DEBUG("glGetShaderInfoLog() -- done");
    }
}
EXPORT void STDCALL glGetShaderPrecisionFormat(uint32_t shader_type, uint32_t precision_type, GLint* range, GLint* precision) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetShaderPrecisionFormat(%u, %u, %p, %p)", shader_type, precision_type, range, precision);
    if (s->enter("glGetShaderPrecisionFormat")) {
        s->glGetShaderPrecisionFormat(shader_type, precision_type, range, precision);
        s->exit();
        GAPID_DEBUG("glGetShaderPrecisionFormat() -- done");
    } else {
        GAPID_INFO("glGetShaderPrecisionFormat at %p: GAPII re-entered. Just invoking imported function at %p", glGetShaderPrecisionFormat, s->GlesSpy::imports().glGetShaderPrecisionFormat);
        s->GlesSpy::imports().glGetShaderPrecisionFormat(shader_type, precision_type, range, precision);
        GAPID_DEBUG("glGetShaderPrecisionFormat() -- done");
    }
}
EXPORT void STDCALL glGetShaderSource(ShaderId shader, GLsizei buffer_length, GLsizei* string_length_written, GLchar* source) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, buffer_length, string_length_written, source);
    if (s->enter("glGetShaderSource")) {
        s->glGetShaderSource(shader, buffer_length, string_length_written, source);
        s->exit();
        GAPID_DEBUG("glGetShaderSource() -- done");
    } else {
        GAPID_INFO("glGetShaderSource at %p: GAPII re-entered. Just invoking imported function at %p", glGetShaderSource, s->GlesSpy::imports().glGetShaderSource);
        s->GlesSpy::imports().glGetShaderSource(shader, buffer_length, string_length_written, source);
        GAPID_DEBUG("glGetShaderSource() -- done");
    }
}
EXPORT void STDCALL glGetShaderiv(ShaderId shader, uint32_t parameter, GLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetShaderiv(%" PRIu32 ", %u, %p)", shader, parameter, value);
    if (s->enter("glGetShaderiv")) {
        s->glGetShaderiv(shader, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetShaderiv() -- done");
    } else {
        GAPID_INFO("glGetShaderiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetShaderiv, s->GlesSpy::imports().glGetShaderiv);
        s->GlesSpy::imports().glGetShaderiv(shader, parameter, value);
        GAPID_DEBUG("glGetShaderiv() -- done");
    }
}
EXPORT UniformBlockId STDCALL glGetUniformBlockIndex(ProgramId program, const char* uniformBlockName) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformBlockIndex(%" PRIu32 ", %s)", program, uniformBlockName);
    if (s->enter("glGetUniformBlockIndex")) {
        auto _result_ = s->glGetUniformBlockIndex(program, uniformBlockName);
        s->exit();
        GAPID_DEBUG("glGetUniformBlockIndex() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetUniformBlockIndex at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformBlockIndex, s->GlesSpy::imports().glGetUniformBlockIndex);
        auto _result_ = s->GlesSpy::imports().glGetUniformBlockIndex(program, uniformBlockName);
        GAPID_DEBUG("glGetUniformBlockIndex() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetUniformIndices(ProgramId program, GLsizei uniformCount, GLchar** uniformNames, UniformIndex* uniformIndices) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformIndices(%" PRIu32 ", %" PRId32 ", %p, %p)", program, uniformCount, uniformNames, uniformIndices);
    if (s->enter("glGetUniformIndices")) {
        s->glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
        s->exit();
        GAPID_DEBUG("glGetUniformIndices() -- done");
    } else {
        GAPID_INFO("glGetUniformIndices at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformIndices, s->GlesSpy::imports().glGetUniformIndices);
        s->GlesSpy::imports().glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
        GAPID_DEBUG("glGetUniformIndices() -- done");
    }
}
EXPORT UniformLocation STDCALL glGetUniformLocation(ProgramId program, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformLocation(%" PRIu32 ", %s)", program, name);
    if (s->enter("glGetUniformLocation")) {
        auto _result_ = s->glGetUniformLocation(program, name);
        s->exit();
        GAPID_DEBUG("glGetUniformLocation() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetUniformLocation at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformLocation, s->GlesSpy::imports().glGetUniformLocation);
        auto _result_ = s->GlesSpy::imports().glGetUniformLocation(program, name);
        GAPID_DEBUG("glGetUniformLocation() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetUniformfv(ProgramId program, UniformLocation location, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformfv(%" PRIu32 ", %" PRId32 ", %p)", program, location, values);
    if (s->enter("glGetUniformfv")) {
        s->glGetUniformfv(program, location, values);
        s->exit();
        GAPID_DEBUG("glGetUniformfv() -- done");
    } else {
        GAPID_INFO("glGetUniformfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformfv, s->GlesSpy::imports().glGetUniformfv);
        s->GlesSpy::imports().glGetUniformfv(program, location, values);
        GAPID_DEBUG("glGetUniformfv() -- done");
    }
}
EXPORT void STDCALL glGetUniformiv(ProgramId program, UniformLocation location, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformiv(%" PRIu32 ", %" PRId32 ", %p)", program, location, values);
    if (s->enter("glGetUniformiv")) {
        s->glGetUniformiv(program, location, values);
        s->exit();
        GAPID_DEBUG("glGetUniformiv() -- done");
    } else {
        GAPID_INFO("glGetUniformiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformiv, s->GlesSpy::imports().glGetUniformiv);
        s->GlesSpy::imports().glGetUniformiv(program, location, values);
        GAPID_DEBUG("glGetUniformiv() -- done");
    }
}
EXPORT void STDCALL glGetUniformuiv(ProgramId program, UniformLocation location, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformuiv(%" PRIu32 ", %" PRId32 ", %p)", program, location, values);
    if (s->enter("glGetUniformuiv")) {
        s->glGetUniformuiv(program, location, values);
        s->exit();
        GAPID_DEBUG("glGetUniformuiv() -- done");
    } else {
        GAPID_INFO("glGetUniformuiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformuiv, s->GlesSpy::imports().glGetUniformuiv);
        s->GlesSpy::imports().glGetUniformuiv(program, location, values);
        GAPID_DEBUG("glGetUniformuiv() -- done");
    }
}
EXPORT void STDCALL glGetnUniformfv(ProgramId program, UniformLocation location, GLsizei bufSize, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformfv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, values);
    if (s->enter("glGetnUniformfv")) {
        s->glGetnUniformfv(program, location, bufSize, values);
        s->exit();
        GAPID_DEBUG("glGetnUniformfv() -- done");
    } else {
        GAPID_INFO("glGetnUniformfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformfv, s->GlesSpy::imports().glGetnUniformfv);
        s->GlesSpy::imports().glGetnUniformfv(program, location, bufSize, values);
        GAPID_DEBUG("glGetnUniformfv() -- done");
    }
}
EXPORT void STDCALL glGetnUniformiv(ProgramId program, UniformLocation location, GLsizei bufSize, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, values);
    if (s->enter("glGetnUniformiv")) {
        s->glGetnUniformiv(program, location, bufSize, values);
        s->exit();
        GAPID_DEBUG("glGetnUniformiv() -- done");
    } else {
        GAPID_INFO("glGetnUniformiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformiv, s->GlesSpy::imports().glGetnUniformiv);
        s->GlesSpy::imports().glGetnUniformiv(program, location, bufSize, values);
        GAPID_DEBUG("glGetnUniformiv() -- done");
    }
}
EXPORT void STDCALL glGetnUniformuiv(ProgramId program, UniformLocation location, GLsizei bufSize, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetnUniformuiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, values);
    if (s->enter("glGetnUniformuiv")) {
        s->glGetnUniformuiv(program, location, bufSize, values);
        s->exit();
        GAPID_DEBUG("glGetnUniformuiv() -- done");
    } else {
        GAPID_INFO("glGetnUniformuiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetnUniformuiv, s->GlesSpy::imports().glGetnUniformuiv);
        s->GlesSpy::imports().glGetnUniformuiv(program, location, bufSize, values);
        GAPID_DEBUG("glGetnUniformuiv() -- done");
    }
}
EXPORT GLboolean STDCALL glIsProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsProgram(%" PRIu32 ")", program);
    if (s->enter("glIsProgram")) {
        auto _result_ = s->glIsProgram(program);
        s->exit();
        GAPID_DEBUG("glIsProgram() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsProgram at %p: GAPII re-entered. Just invoking imported function at %p", glIsProgram, s->GlesSpy::imports().glIsProgram);
        auto _result_ = s->GlesSpy::imports().glIsProgram(program);
        GAPID_DEBUG("glIsProgram() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsProgramPipeline(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsProgramPipeline(%" PRIu32 ")", pipeline);
    if (s->enter("glIsProgramPipeline")) {
        auto _result_ = s->glIsProgramPipeline(pipeline);
        s->exit();
        GAPID_DEBUG("glIsProgramPipeline() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsProgramPipeline at %p: GAPII re-entered. Just invoking imported function at %p", glIsProgramPipeline, s->GlesSpy::imports().glIsProgramPipeline);
        auto _result_ = s->GlesSpy::imports().glIsProgramPipeline(pipeline);
        GAPID_DEBUG("glIsProgramPipeline() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsShader(ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsShader(%" PRIu32 ")", shader);
    if (s->enter("glIsShader")) {
        auto _result_ = s->glIsShader(shader);
        s->exit();
        GAPID_DEBUG("glIsShader() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsShader at %p: GAPII re-entered. Just invoking imported function at %p", glIsShader, s->GlesSpy::imports().glIsShader);
        auto _result_ = s->GlesSpy::imports().glIsShader(shader);
        GAPID_DEBUG("glIsShader() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glLinkProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLinkProgram(%" PRIu32 ")", program);
    if (s->enter("glLinkProgram")) {
        s->glLinkProgram(program);
        s->exit();
        GAPID_DEBUG("glLinkProgram() -- done");
    } else {
        GAPID_INFO("glLinkProgram at %p: GAPII re-entered. Just invoking imported function at %p", glLinkProgram, s->GlesSpy::imports().glLinkProgram);
        s->GlesSpy::imports().glLinkProgram(program);
        GAPID_DEBUG("glLinkProgram() -- done");
    }
}
EXPORT void STDCALL glMemoryBarrier(uint32_t barriers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMemoryBarrier(%u)", barriers);
    if (s->enter("glMemoryBarrier")) {
        s->glMemoryBarrier(barriers);
        s->exit();
        GAPID_DEBUG("glMemoryBarrier() -- done");
    } else {
        GAPID_INFO("glMemoryBarrier at %p: GAPII re-entered. Just invoking imported function at %p", glMemoryBarrier, s->GlesSpy::imports().glMemoryBarrier);
        s->GlesSpy::imports().glMemoryBarrier(barriers);
        GAPID_DEBUG("glMemoryBarrier() -- done");
    }
}
EXPORT void STDCALL glMemoryBarrierByRegion(uint32_t barriers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMemoryBarrierByRegion(%u)", barriers);
    if (s->enter("glMemoryBarrierByRegion")) {
        s->glMemoryBarrierByRegion(barriers);
        s->exit();
        GAPID_DEBUG("glMemoryBarrierByRegion() -- done");
    } else {
        GAPID_INFO("glMemoryBarrierByRegion at %p: GAPII re-entered. Just invoking imported function at %p", glMemoryBarrierByRegion, s->GlesSpy::imports().glMemoryBarrierByRegion);
        s->GlesSpy::imports().glMemoryBarrierByRegion(barriers);
        GAPID_DEBUG("glMemoryBarrierByRegion() -- done");
    }
}
EXPORT void STDCALL glProgramBinary(ProgramId program, uint32_t binaryFormat, void* binary, GLsizei length) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramBinary(%" PRIu32 ", %u, %p, %" PRId32 ")", program, binaryFormat, binary, length);
    if (s->enter("glProgramBinary")) {
        s->glProgramBinary(program, binaryFormat, binary, length);
        s->exit();
        GAPID_DEBUG("glProgramBinary() -- done");
    } else {
        GAPID_INFO("glProgramBinary at %p: GAPII re-entered. Just invoking imported function at %p", glProgramBinary, s->GlesSpy::imports().glProgramBinary);
        s->GlesSpy::imports().glProgramBinary(program, binaryFormat, binary, length);
        GAPID_DEBUG("glProgramBinary() -- done");
    }
}
EXPORT void STDCALL glProgramParameteri(ProgramId program, uint32_t pname, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramParameteri(%" PRIu32 ", %u, %" PRId32 ")", program, pname, value);
    if (s->enter("glProgramParameteri")) {
        s->glProgramParameteri(program, pname, value);
        s->exit();
        GAPID_DEBUG("glProgramParameteri() -- done");
    } else {
        GAPID_INFO("glProgramParameteri at %p: GAPII re-entered. Just invoking imported function at %p", glProgramParameteri, s->GlesSpy::imports().glProgramParameteri);
        s->GlesSpy::imports().glProgramParameteri(program, pname, value);
        GAPID_DEBUG("glProgramParameteri() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1f(ProgramId program, UniformLocation location, GLfloat value0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1f(%" PRIu32 ", %" PRId32 ", %f)", program, location, value0);
    if (s->enter("glProgramUniform1f")) {
        s->glProgramUniform1f(program, location, value0);
        s->exit();
        GAPID_DEBUG("glProgramUniform1f() -- done");
    } else {
        GAPID_INFO("glProgramUniform1f at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1f, s->GlesSpy::imports().glProgramUniform1f);
        s->GlesSpy::imports().glProgramUniform1f(program, location, value0);
        GAPID_DEBUG("glProgramUniform1f() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform1fv")) {
        s->glProgramUniform1fv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform1fv() -- done");
    } else {
        GAPID_INFO("glProgramUniform1fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1fv, s->GlesSpy::imports().glProgramUniform1fv);
        s->GlesSpy::imports().glProgramUniform1fv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform1fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1i(ProgramId program, UniformLocation location, GLint value0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1i(%" PRIu32 ", %" PRId32 ", %" PRId32 ")", program, location, value0);
    if (s->enter("glProgramUniform1i")) {
        s->glProgramUniform1i(program, location, value0);
        s->exit();
        GAPID_DEBUG("glProgramUniform1i() -- done");
    } else {
        GAPID_INFO("glProgramUniform1i at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1i, s->GlesSpy::imports().glProgramUniform1i);
        s->GlesSpy::imports().glProgramUniform1i(program, location, value0);
        GAPID_DEBUG("glProgramUniform1i() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform1iv")) {
        s->glProgramUniform1iv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform1iv() -- done");
    } else {
        GAPID_INFO("glProgramUniform1iv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1iv, s->GlesSpy::imports().glProgramUniform1iv);
        s->GlesSpy::imports().glProgramUniform1iv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform1iv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1ui(ProgramId program, UniformLocation location, GLuint value0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")", program, location, value0);
    if (s->enter("glProgramUniform1ui")) {
        s->glProgramUniform1ui(program, location, value0);
        s->exit();
        GAPID_DEBUG("glProgramUniform1ui() -- done");
    } else {
        GAPID_INFO("glProgramUniform1ui at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1ui, s->GlesSpy::imports().glProgramUniform1ui);
        s->GlesSpy::imports().glProgramUniform1ui(program, location, value0);
        GAPID_DEBUG("glProgramUniform1ui() -- done");
    }
}
EXPORT void STDCALL glProgramUniform1uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform1uiv")) {
        s->glProgramUniform1uiv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform1uiv() -- done");
    } else {
        GAPID_INFO("glProgramUniform1uiv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1uiv, s->GlesSpy::imports().glProgramUniform1uiv);
        s->GlesSpy::imports().glProgramUniform1uiv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform1uiv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2f(ProgramId program, UniformLocation location, GLfloat value0, GLfloat value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2f(%" PRIu32 ", %" PRId32 ", %f, %f)", program, location, value0, value1);
    if (s->enter("glProgramUniform2f")) {
        s->glProgramUniform2f(program, location, value0, value1);
        s->exit();
        GAPID_DEBUG("glProgramUniform2f() -- done");
    } else {
        GAPID_INFO("glProgramUniform2f at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2f, s->GlesSpy::imports().glProgramUniform2f);
        s->GlesSpy::imports().glProgramUniform2f(program, location, value0, value1);
        GAPID_DEBUG("glProgramUniform2f() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform2fv")) {
        s->glProgramUniform2fv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform2fv() -- done");
    } else {
        GAPID_INFO("glProgramUniform2fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2fv, s->GlesSpy::imports().glProgramUniform2fv);
        s->GlesSpy::imports().glProgramUniform2fv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform2fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2i(ProgramId program, UniformLocation location, GLint value0, GLint value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, value0, value1);
    if (s->enter("glProgramUniform2i")) {
        s->glProgramUniform2i(program, location, value0, value1);
        s->exit();
        GAPID_DEBUG("glProgramUniform2i() -- done");
    } else {
        GAPID_INFO("glProgramUniform2i at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2i, s->GlesSpy::imports().glProgramUniform2i);
        s->GlesSpy::imports().glProgramUniform2i(program, location, value0, value1);
        GAPID_DEBUG("glProgramUniform2i() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform2iv")) {
        s->glProgramUniform2iv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform2iv() -- done");
    } else {
        GAPID_INFO("glProgramUniform2iv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2iv, s->GlesSpy::imports().glProgramUniform2iv);
        s->GlesSpy::imports().glProgramUniform2iv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform2iv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2ui(ProgramId program, UniformLocation location, GLuint value0, GLuint value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ")", program, location, value0, value1);
    if (s->enter("glProgramUniform2ui")) {
        s->glProgramUniform2ui(program, location, value0, value1);
        s->exit();
        GAPID_DEBUG("glProgramUniform2ui() -- done");
    } else {
        GAPID_INFO("glProgramUniform2ui at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2ui, s->GlesSpy::imports().glProgramUniform2ui);
        s->GlesSpy::imports().glProgramUniform2ui(program, location, value0, value1);
        GAPID_DEBUG("glProgramUniform2ui() -- done");
    }
}
EXPORT void STDCALL glProgramUniform2uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform2uiv")) {
        s->glProgramUniform2uiv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform2uiv() -- done");
    } else {
        GAPID_INFO("glProgramUniform2uiv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2uiv, s->GlesSpy::imports().glProgramUniform2uiv);
        s->GlesSpy::imports().glProgramUniform2uiv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform2uiv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3f(ProgramId program, UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3f(%" PRIu32 ", %" PRId32 ", %f, %f, %f)", program, location, value0, value1, value2);
    if (s->enter("glProgramUniform3f")) {
        s->glProgramUniform3f(program, location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glProgramUniform3f() -- done");
    } else {
        GAPID_INFO("glProgramUniform3f at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3f, s->GlesSpy::imports().glProgramUniform3f);
        s->GlesSpy::imports().glProgramUniform3f(program, location, value0, value1, value2);
        GAPID_DEBUG("glProgramUniform3f() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform3fv")) {
        s->glProgramUniform3fv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform3fv() -- done");
    } else {
        GAPID_INFO("glProgramUniform3fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3fv, s->GlesSpy::imports().glProgramUniform3fv);
        s->GlesSpy::imports().glProgramUniform3fv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform3fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3i(ProgramId program, UniformLocation location, GLint value0, GLint value1, GLint value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, value0, value1, value2);
    if (s->enter("glProgramUniform3i")) {
        s->glProgramUniform3i(program, location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glProgramUniform3i() -- done");
    } else {
        GAPID_INFO("glProgramUniform3i at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3i, s->GlesSpy::imports().glProgramUniform3i);
        s->GlesSpy::imports().glProgramUniform3i(program, location, value0, value1, value2);
        GAPID_DEBUG("glProgramUniform3i() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform3iv")) {
        s->glProgramUniform3iv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform3iv() -- done");
    } else {
        GAPID_INFO("glProgramUniform3iv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3iv, s->GlesSpy::imports().glProgramUniform3iv);
        s->GlesSpy::imports().glProgramUniform3iv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform3iv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3ui(ProgramId program, UniformLocation location, GLuint value0, GLuint value1, GLuint value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, value0, value1, value2);
    if (s->enter("glProgramUniform3ui")) {
        s->glProgramUniform3ui(program, location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glProgramUniform3ui() -- done");
    } else {
        GAPID_INFO("glProgramUniform3ui at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3ui, s->GlesSpy::imports().glProgramUniform3ui);
        s->GlesSpy::imports().glProgramUniform3ui(program, location, value0, value1, value2);
        GAPID_DEBUG("glProgramUniform3ui() -- done");
    }
}
EXPORT void STDCALL glProgramUniform3uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform3uiv")) {
        s->glProgramUniform3uiv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform3uiv() -- done");
    } else {
        GAPID_INFO("glProgramUniform3uiv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3uiv, s->GlesSpy::imports().glProgramUniform3uiv);
        s->GlesSpy::imports().glProgramUniform3uiv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform3uiv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4f(ProgramId program, UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4f(%" PRIu32 ", %" PRId32 ", %f, %f, %f, %f)", program, location, value0, value1, value2, value3);
    if (s->enter("glProgramUniform4f")) {
        s->glProgramUniform4f(program, location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glProgramUniform4f() -- done");
    } else {
        GAPID_INFO("glProgramUniform4f at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4f, s->GlesSpy::imports().glProgramUniform4f);
        s->GlesSpy::imports().glProgramUniform4f(program, location, value0, value1, value2, value3);
        GAPID_DEBUG("glProgramUniform4f() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4fv(ProgramId program, UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform4fv")) {
        s->glProgramUniform4fv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform4fv() -- done");
    } else {
        GAPID_INFO("glProgramUniform4fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4fv, s->GlesSpy::imports().glProgramUniform4fv);
        s->GlesSpy::imports().glProgramUniform4fv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform4fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4i(ProgramId program, UniformLocation location, GLint value0, GLint value1, GLint value2, GLint value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, value0, value1, value2, value3);
    if (s->enter("glProgramUniform4i")) {
        s->glProgramUniform4i(program, location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glProgramUniform4i() -- done");
    } else {
        GAPID_INFO("glProgramUniform4i at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4i, s->GlesSpy::imports().glProgramUniform4i);
        s->GlesSpy::imports().glProgramUniform4i(program, location, value0, value1, value2, value3);
        GAPID_DEBUG("glProgramUniform4i() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4iv(ProgramId program, UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform4iv")) {
        s->glProgramUniform4iv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform4iv() -- done");
    } else {
        GAPID_INFO("glProgramUniform4iv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4iv, s->GlesSpy::imports().glProgramUniform4iv);
        s->GlesSpy::imports().glProgramUniform4iv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform4iv() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4ui(ProgramId program, UniformLocation location, GLuint value0, GLuint value1, GLuint value2, GLuint value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, value0, value1, value2, value3);
    if (s->enter("glProgramUniform4ui")) {
        s->glProgramUniform4ui(program, location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glProgramUniform4ui() -- done");
    } else {
        GAPID_INFO("glProgramUniform4ui at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4ui, s->GlesSpy::imports().glProgramUniform4ui);
        s->GlesSpy::imports().glProgramUniform4ui(program, location, value0, value1, value2, value3);
        GAPID_DEBUG("glProgramUniform4ui() -- done");
    }
}
EXPORT void STDCALL glProgramUniform4uiv(ProgramId program, UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (s->enter("glProgramUniform4uiv")) {
        s->glProgramUniform4uiv(program, location, count, values);
        s->exit();
        GAPID_DEBUG("glProgramUniform4uiv() -- done");
    } else {
        GAPID_INFO("glProgramUniform4uiv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4uiv, s->GlesSpy::imports().glProgramUniform4uiv);
        s->GlesSpy::imports().glProgramUniform4uiv(program, location, count, values);
        GAPID_DEBUG("glProgramUniform4uiv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix2fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix2fv")) {
        s->glProgramUniformMatrix2fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix2fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix2fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix2fv, s->GlesSpy::imports().glProgramUniformMatrix2fv);
        s->GlesSpy::imports().glProgramUniformMatrix2fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix2fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix2x3fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix2x3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix2x3fv")) {
        s->glProgramUniformMatrix2x3fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix2x3fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix2x3fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix2x3fv, s->GlesSpy::imports().glProgramUniformMatrix2x3fv);
        s->GlesSpy::imports().glProgramUniformMatrix2x3fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix2x3fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix2x4fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix2x4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix2x4fv")) {
        s->glProgramUniformMatrix2x4fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix2x4fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix2x4fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix2x4fv, s->GlesSpy::imports().glProgramUniformMatrix2x4fv);
        s->GlesSpy::imports().glProgramUniformMatrix2x4fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix2x4fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix3fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix3fv")) {
        s->glProgramUniformMatrix3fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix3fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix3fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix3fv, s->GlesSpy::imports().glProgramUniformMatrix3fv);
        s->GlesSpy::imports().glProgramUniformMatrix3fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix3fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix3x2fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix3x2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix3x2fv")) {
        s->glProgramUniformMatrix3x2fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix3x2fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix3x2fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix3x2fv, s->GlesSpy::imports().glProgramUniformMatrix3x2fv);
        s->GlesSpy::imports().glProgramUniformMatrix3x2fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix3x2fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix3x4fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix3x4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix3x4fv")) {
        s->glProgramUniformMatrix3x4fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix3x4fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix3x4fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix3x4fv, s->GlesSpy::imports().glProgramUniformMatrix3x4fv);
        s->GlesSpy::imports().glProgramUniformMatrix3x4fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix3x4fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix4fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix4fv")) {
        s->glProgramUniformMatrix4fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix4fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix4fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix4fv, s->GlesSpy::imports().glProgramUniformMatrix4fv);
        s->GlesSpy::imports().glProgramUniformMatrix4fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix4fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix4x2fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix4x2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix4x2fv")) {
        s->glProgramUniformMatrix4x2fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix4x2fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix4x2fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix4x2fv, s->GlesSpy::imports().glProgramUniformMatrix4x2fv);
        s->GlesSpy::imports().glProgramUniformMatrix4x2fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix4x2fv() -- done");
    }
}
EXPORT void STDCALL glProgramUniformMatrix4x3fv(ProgramId program, UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformMatrix4x3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
    if (s->enter("glProgramUniformMatrix4x3fv")) {
        s->glProgramUniformMatrix4x3fv(program, location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glProgramUniformMatrix4x3fv() -- done");
    } else {
        GAPID_INFO("glProgramUniformMatrix4x3fv at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformMatrix4x3fv, s->GlesSpy::imports().glProgramUniformMatrix4x3fv);
        s->GlesSpy::imports().glProgramUniformMatrix4x3fv(program, location, count, transpose, values);
        GAPID_DEBUG("glProgramUniformMatrix4x3fv() -- done");
    }
}
EXPORT void STDCALL glReleaseShaderCompiler() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReleaseShaderCompiler()");
    if (s->enter("glReleaseShaderCompiler")) {
        s->glReleaseShaderCompiler();
        s->exit();
        GAPID_DEBUG("glReleaseShaderCompiler() -- done");
    } else {
        GAPID_INFO("glReleaseShaderCompiler at %p: GAPII re-entered. Just invoking imported function at %p", glReleaseShaderCompiler, s->GlesSpy::imports().glReleaseShaderCompiler);
        s->GlesSpy::imports().glReleaseShaderCompiler();
        GAPID_DEBUG("glReleaseShaderCompiler() -- done");
    }
}
EXPORT void STDCALL glShaderBinary(GLsizei count, ShaderId* shaders, uint32_t binary_format, void* binary, GLsizei binary_size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glShaderBinary(%" PRId32 ", %p, %u, %p, %" PRId32 ")", count, shaders, binary_format, binary, binary_size);
    if (s->enter("glShaderBinary")) {
        s->glShaderBinary(count, shaders, binary_format, binary, binary_size);
        s->exit();
        GAPID_DEBUG("glShaderBinary() -- done");
    } else {
        GAPID_INFO("glShaderBinary at %p: GAPII re-entered. Just invoking imported function at %p", glShaderBinary, s->GlesSpy::imports().glShaderBinary);
        s->GlesSpy::imports().glShaderBinary(count, shaders, binary_format, binary, binary_size);
        GAPID_DEBUG("glShaderBinary() -- done");
    }
}
EXPORT void STDCALL glShaderSource(ShaderId shader, GLsizei count, GLchar** source, GLint* length) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, count, source, length);
    if (s->enter("glShaderSource")) {
        s->glShaderSource(shader, count, source, length);
        s->exit();
        GAPID_DEBUG("glShaderSource() -- done");
    } else {
        GAPID_INFO("glShaderSource at %p: GAPII re-entered. Just invoking imported function at %p", glShaderSource, s->GlesSpy::imports().glShaderSource);
        s->GlesSpy::imports().glShaderSource(shader, count, source, length);
        GAPID_DEBUG("glShaderSource() -- done");
    }
}
EXPORT void STDCALL glUniform1f(UniformLocation location, GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1f(%" PRId32 ", %f)", location, value);
    if (s->enter("glUniform1f")) {
        s->glUniform1f(location, value);
        s->exit();
        GAPID_DEBUG("glUniform1f() -- done");
    } else {
        GAPID_INFO("glUniform1f at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1f, s->GlesSpy::imports().glUniform1f);
        s->GlesSpy::imports().glUniform1f(location, value);
        GAPID_DEBUG("glUniform1f() -- done");
    }
}
EXPORT void STDCALL glUniform1fv(UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform1fv")) {
        s->glUniform1fv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform1fv() -- done");
    } else {
        GAPID_INFO("glUniform1fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1fv, s->GlesSpy::imports().glUniform1fv);
        s->GlesSpy::imports().glUniform1fv(location, count, values);
        GAPID_DEBUG("glUniform1fv() -- done");
    }
}
EXPORT void STDCALL glUniform1i(UniformLocation location, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1i(%" PRId32 ", %" PRId32 ")", location, value);
    if (s->enter("glUniform1i")) {
        s->glUniform1i(location, value);
        s->exit();
        GAPID_DEBUG("glUniform1i() -- done");
    } else {
        GAPID_INFO("glUniform1i at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1i, s->GlesSpy::imports().glUniform1i);
        s->GlesSpy::imports().glUniform1i(location, value);
        GAPID_DEBUG("glUniform1i() -- done");
    }
}
EXPORT void STDCALL glUniform1iv(UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform1iv")) {
        s->glUniform1iv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform1iv() -- done");
    } else {
        GAPID_INFO("glUniform1iv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1iv, s->GlesSpy::imports().glUniform1iv);
        s->GlesSpy::imports().glUniform1iv(location, count, values);
        GAPID_DEBUG("glUniform1iv() -- done");
    }
}
EXPORT void STDCALL glUniform1ui(UniformLocation location, GLuint value0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1ui(%" PRId32 ", %" PRIu32 ")", location, value0);
    if (s->enter("glUniform1ui")) {
        s->glUniform1ui(location, value0);
        s->exit();
        GAPID_DEBUG("glUniform1ui() -- done");
    } else {
        GAPID_INFO("glUniform1ui at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1ui, s->GlesSpy::imports().glUniform1ui);
        s->GlesSpy::imports().glUniform1ui(location, value0);
        GAPID_DEBUG("glUniform1ui() -- done");
    }
}
EXPORT void STDCALL glUniform1uiv(UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform1uiv")) {
        s->glUniform1uiv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform1uiv() -- done");
    } else {
        GAPID_INFO("glUniform1uiv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1uiv, s->GlesSpy::imports().glUniform1uiv);
        s->GlesSpy::imports().glUniform1uiv(location, count, values);
        GAPID_DEBUG("glUniform1uiv() -- done");
    }
}
EXPORT void STDCALL glUniform2f(UniformLocation location, GLfloat value0, GLfloat value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2f(%" PRId32 ", %f, %f)", location, value0, value1);
    if (s->enter("glUniform2f")) {
        s->glUniform2f(location, value0, value1);
        s->exit();
        GAPID_DEBUG("glUniform2f() -- done");
    } else {
        GAPID_INFO("glUniform2f at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2f, s->GlesSpy::imports().glUniform2f);
        s->GlesSpy::imports().glUniform2f(location, value0, value1);
        GAPID_DEBUG("glUniform2f() -- done");
    }
}
EXPORT void STDCALL glUniform2fv(UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform2fv")) {
        s->glUniform2fv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform2fv() -- done");
    } else {
        GAPID_INFO("glUniform2fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2fv, s->GlesSpy::imports().glUniform2fv);
        s->GlesSpy::imports().glUniform2fv(location, count, values);
        GAPID_DEBUG("glUniform2fv() -- done");
    }
}
EXPORT void STDCALL glUniform2i(UniformLocation location, GLint value0, GLint value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2i(%" PRId32 ", %" PRId32 ", %" PRId32 ")", location, value0, value1);
    if (s->enter("glUniform2i")) {
        s->glUniform2i(location, value0, value1);
        s->exit();
        GAPID_DEBUG("glUniform2i() -- done");
    } else {
        GAPID_INFO("glUniform2i at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2i, s->GlesSpy::imports().glUniform2i);
        s->GlesSpy::imports().glUniform2i(location, value0, value1);
        GAPID_DEBUG("glUniform2i() -- done");
    }
}
EXPORT void STDCALL glUniform2iv(UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform2iv")) {
        s->glUniform2iv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform2iv() -- done");
    } else {
        GAPID_INFO("glUniform2iv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2iv, s->GlesSpy::imports().glUniform2iv);
        s->GlesSpy::imports().glUniform2iv(location, count, values);
        GAPID_DEBUG("glUniform2iv() -- done");
    }
}
EXPORT void STDCALL glUniform2ui(UniformLocation location, GLuint value0, GLuint value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ")", location, value0, value1);
    if (s->enter("glUniform2ui")) {
        s->glUniform2ui(location, value0, value1);
        s->exit();
        GAPID_DEBUG("glUniform2ui() -- done");
    } else {
        GAPID_INFO("glUniform2ui at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2ui, s->GlesSpy::imports().glUniform2ui);
        s->GlesSpy::imports().glUniform2ui(location, value0, value1);
        GAPID_DEBUG("glUniform2ui() -- done");
    }
}
EXPORT void STDCALL glUniform2uiv(UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform2uiv")) {
        s->glUniform2uiv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform2uiv() -- done");
    } else {
        GAPID_INFO("glUniform2uiv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2uiv, s->GlesSpy::imports().glUniform2uiv);
        s->GlesSpy::imports().glUniform2uiv(location, count, values);
        GAPID_DEBUG("glUniform2uiv() -- done");
    }
}
EXPORT void STDCALL glUniform3f(UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3f(%" PRId32 ", %f, %f, %f)", location, value0, value1, value2);
    if (s->enter("glUniform3f")) {
        s->glUniform3f(location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glUniform3f() -- done");
    } else {
        GAPID_INFO("glUniform3f at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3f, s->GlesSpy::imports().glUniform3f);
        s->GlesSpy::imports().glUniform3f(location, value0, value1, value2);
        GAPID_DEBUG("glUniform3f() -- done");
    }
}
EXPORT void STDCALL glUniform3fv(UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform3fv")) {
        s->glUniform3fv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform3fv() -- done");
    } else {
        GAPID_INFO("glUniform3fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3fv, s->GlesSpy::imports().glUniform3fv);
        s->GlesSpy::imports().glUniform3fv(location, count, values);
        GAPID_DEBUG("glUniform3fv() -- done");
    }
}
EXPORT void STDCALL glUniform3i(UniformLocation location, GLint value0, GLint value1, GLint value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", location, value0, value1, value2);
    if (s->enter("glUniform3i")) {
        s->glUniform3i(location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glUniform3i() -- done");
    } else {
        GAPID_INFO("glUniform3i at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3i, s->GlesSpy::imports().glUniform3i);
        s->GlesSpy::imports().glUniform3i(location, value0, value1, value2);
        GAPID_DEBUG("glUniform3i() -- done");
    }
}
EXPORT void STDCALL glUniform3iv(UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform3iv")) {
        s->glUniform3iv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform3iv() -- done");
    } else {
        GAPID_INFO("glUniform3iv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3iv, s->GlesSpy::imports().glUniform3iv);
        s->GlesSpy::imports().glUniform3iv(location, count, values);
        GAPID_DEBUG("glUniform3iv() -- done");
    }
}
EXPORT void STDCALL glUniform3ui(UniformLocation location, GLuint value0, GLuint value1, GLuint value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", location, value0, value1, value2);
    if (s->enter("glUniform3ui")) {
        s->glUniform3ui(location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glUniform3ui() -- done");
    } else {
        GAPID_INFO("glUniform3ui at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3ui, s->GlesSpy::imports().glUniform3ui);
        s->GlesSpy::imports().glUniform3ui(location, value0, value1, value2);
        GAPID_DEBUG("glUniform3ui() -- done");
    }
}
EXPORT void STDCALL glUniform3uiv(UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform3uiv")) {
        s->glUniform3uiv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform3uiv() -- done");
    } else {
        GAPID_INFO("glUniform3uiv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3uiv, s->GlesSpy::imports().glUniform3uiv);
        s->GlesSpy::imports().glUniform3uiv(location, count, values);
        GAPID_DEBUG("glUniform3uiv() -- done");
    }
}
EXPORT void STDCALL glUniform4f(UniformLocation location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4f(%" PRId32 ", %f, %f, %f, %f)", location, value0, value1, value2, value3);
    if (s->enter("glUniform4f")) {
        s->glUniform4f(location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glUniform4f() -- done");
    } else {
        GAPID_INFO("glUniform4f at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4f, s->GlesSpy::imports().glUniform4f);
        s->GlesSpy::imports().glUniform4f(location, value0, value1, value2, value3);
        GAPID_DEBUG("glUniform4f() -- done");
    }
}
EXPORT void STDCALL glUniform4fv(UniformLocation location, GLsizei count, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform4fv")) {
        s->glUniform4fv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform4fv() -- done");
    } else {
        GAPID_INFO("glUniform4fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4fv, s->GlesSpy::imports().glUniform4fv);
        s->GlesSpy::imports().glUniform4fv(location, count, values);
        GAPID_DEBUG("glUniform4fv() -- done");
    }
}
EXPORT void STDCALL glUniform4i(UniformLocation location, GLint value0, GLint value1, GLint value2, GLint value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", location, value0, value1, value2, value3);
    if (s->enter("glUniform4i")) {
        s->glUniform4i(location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glUniform4i() -- done");
    } else {
        GAPID_INFO("glUniform4i at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4i, s->GlesSpy::imports().glUniform4i);
        s->GlesSpy::imports().glUniform4i(location, value0, value1, value2, value3);
        GAPID_DEBUG("glUniform4i() -- done");
    }
}
EXPORT void STDCALL glUniform4iv(UniformLocation location, GLsizei count, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform4iv")) {
        s->glUniform4iv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform4iv() -- done");
    } else {
        GAPID_INFO("glUniform4iv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4iv, s->GlesSpy::imports().glUniform4iv);
        s->GlesSpy::imports().glUniform4iv(location, count, values);
        GAPID_DEBUG("glUniform4iv() -- done");
    }
}
EXPORT void STDCALL glUniform4ui(UniformLocation location, GLuint value0, GLuint value1, GLuint value2, GLuint value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", location, value0, value1, value2, value3);
    if (s->enter("glUniform4ui")) {
        s->glUniform4ui(location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glUniform4ui() -- done");
    } else {
        GAPID_INFO("glUniform4ui at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4ui, s->GlesSpy::imports().glUniform4ui);
        s->GlesSpy::imports().glUniform4ui(location, value0, value1, value2, value3);
        GAPID_DEBUG("glUniform4ui() -- done");
    }
}
EXPORT void STDCALL glUniform4uiv(UniformLocation location, GLsizei count, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
    if (s->enter("glUniform4uiv")) {
        s->glUniform4uiv(location, count, values);
        s->exit();
        GAPID_DEBUG("glUniform4uiv() -- done");
    } else {
        GAPID_INFO("glUniform4uiv at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4uiv, s->GlesSpy::imports().glUniform4uiv);
        s->GlesSpy::imports().glUniform4uiv(location, count, values);
        GAPID_DEBUG("glUniform4uiv() -- done");
    }
}
EXPORT void STDCALL glUniformBlockBinding(ProgramId program, UniformBlockId uniform_block_index, GLuint uniform_block_binding) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformBlockBinding(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, uniform_block_index, uniform_block_binding);
    if (s->enter("glUniformBlockBinding")) {
        s->glUniformBlockBinding(program, uniform_block_index, uniform_block_binding);
        s->exit();
        GAPID_DEBUG("glUniformBlockBinding() -- done");
    } else {
        GAPID_INFO("glUniformBlockBinding at %p: GAPII re-entered. Just invoking imported function at %p", glUniformBlockBinding, s->GlesSpy::imports().glUniformBlockBinding);
        s->GlesSpy::imports().glUniformBlockBinding(program, uniform_block_index, uniform_block_binding);
        GAPID_DEBUG("glUniformBlockBinding() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix2fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix2fv")) {
        s->glUniformMatrix2fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix2fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix2fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix2fv, s->GlesSpy::imports().glUniformMatrix2fv);
        s->GlesSpy::imports().glUniformMatrix2fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix2fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix2x3fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix2x3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix2x3fv")) {
        s->glUniformMatrix2x3fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix2x3fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix2x3fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix2x3fv, s->GlesSpy::imports().glUniformMatrix2x3fv);
        s->GlesSpy::imports().glUniformMatrix2x3fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix2x3fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix2x4fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix2x4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix2x4fv")) {
        s->glUniformMatrix2x4fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix2x4fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix2x4fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix2x4fv, s->GlesSpy::imports().glUniformMatrix2x4fv);
        s->GlesSpy::imports().glUniformMatrix2x4fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix2x4fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix3fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix3fv")) {
        s->glUniformMatrix3fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix3fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix3fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix3fv, s->GlesSpy::imports().glUniformMatrix3fv);
        s->GlesSpy::imports().glUniformMatrix3fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix3fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix3x2fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix3x2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix3x2fv")) {
        s->glUniformMatrix3x2fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix3x2fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix3x2fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix3x2fv, s->GlesSpy::imports().glUniformMatrix3x2fv);
        s->GlesSpy::imports().glUniformMatrix3x2fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix3x2fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix3x4fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix3x4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix3x4fv")) {
        s->glUniformMatrix3x4fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix3x4fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix3x4fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix3x4fv, s->GlesSpy::imports().glUniformMatrix3x4fv);
        s->GlesSpy::imports().glUniformMatrix3x4fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix3x4fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix4fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix4fv")) {
        s->glUniformMatrix4fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix4fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix4fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix4fv, s->GlesSpy::imports().glUniformMatrix4fv);
        s->GlesSpy::imports().glUniformMatrix4fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix4fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix4x2fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix4x2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix4x2fv")) {
        s->glUniformMatrix4x2fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix4x2fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix4x2fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix4x2fv, s->GlesSpy::imports().glUniformMatrix4x2fv);
        s->GlesSpy::imports().glUniformMatrix4x2fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix4x2fv() -- done");
    }
}
EXPORT void STDCALL glUniformMatrix4x3fv(UniformLocation location, GLsizei count, GLboolean transpose, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformMatrix4x3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
    if (s->enter("glUniformMatrix4x3fv")) {
        s->glUniformMatrix4x3fv(location, count, transpose, values);
        s->exit();
        GAPID_DEBUG("glUniformMatrix4x3fv() -- done");
    } else {
        GAPID_INFO("glUniformMatrix4x3fv at %p: GAPII re-entered. Just invoking imported function at %p", glUniformMatrix4x3fv, s->GlesSpy::imports().glUniformMatrix4x3fv);
        s->GlesSpy::imports().glUniformMatrix4x3fv(location, count, transpose, values);
        GAPID_DEBUG("glUniformMatrix4x3fv() -- done");
    }
}
EXPORT void STDCALL glUseProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUseProgram(%" PRIu32 ")", program);
    if (s->enter("glUseProgram")) {
        s->glUseProgram(program);
        s->exit();
        GAPID_DEBUG("glUseProgram() -- done");
    } else {
        GAPID_INFO("glUseProgram at %p: GAPII re-entered. Just invoking imported function at %p", glUseProgram, s->GlesSpy::imports().glUseProgram);
        s->GlesSpy::imports().glUseProgram(program);
        GAPID_DEBUG("glUseProgram() -- done");
    }
}
EXPORT void STDCALL glUseProgramStages(PipelineId pipeline, uint32_t stages, ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUseProgramStages(%" PRIu32 ", %u, %" PRIu32 ")", pipeline, stages, program);
    if (s->enter("glUseProgramStages")) {
        s->glUseProgramStages(pipeline, stages, program);
        s->exit();
        GAPID_DEBUG("glUseProgramStages() -- done");
    } else {
        GAPID_INFO("glUseProgramStages at %p: GAPII re-entered. Just invoking imported function at %p", glUseProgramStages, s->GlesSpy::imports().glUseProgramStages);
        s->GlesSpy::imports().glUseProgramStages(pipeline, stages, program);
        GAPID_DEBUG("glUseProgramStages() -- done");
    }
}
EXPORT void STDCALL glValidateProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glValidateProgram(%" PRIu32 ")", program);
    if (s->enter("glValidateProgram")) {
        s->glValidateProgram(program);
        s->exit();
        GAPID_DEBUG("glValidateProgram() -- done");
    } else {
        GAPID_INFO("glValidateProgram at %p: GAPII re-entered. Just invoking imported function at %p", glValidateProgram, s->GlesSpy::imports().glValidateProgram);
        s->GlesSpy::imports().glValidateProgram(program);
        GAPID_DEBUG("glValidateProgram() -- done");
    }
}
EXPORT void STDCALL glValidateProgramPipeline(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glValidateProgramPipeline(%" PRIu32 ")", pipeline);
    if (s->enter("glValidateProgramPipeline")) {
        s->glValidateProgramPipeline(pipeline);
        s->exit();
        GAPID_DEBUG("glValidateProgramPipeline() -- done");
    } else {
        GAPID_INFO("glValidateProgramPipeline at %p: GAPII re-entered. Just invoking imported function at %p", glValidateProgramPipeline, s->GlesSpy::imports().glValidateProgramPipeline);
        s->GlesSpy::imports().glValidateProgramPipeline(pipeline);
        GAPID_DEBUG("glValidateProgramPipeline() -- done");
    }
}
EXPORT void STDCALL glCullFace(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCullFace(%u)", mode);
    if (s->enter("glCullFace")) {
        s->glCullFace(mode);
        s->exit();
        GAPID_DEBUG("glCullFace() -- done");
    } else {
        GAPID_INFO("glCullFace at %p: GAPII re-entered. Just invoking imported function at %p", glCullFace, s->GlesSpy::imports().glCullFace);
        s->GlesSpy::imports().glCullFace(mode);
        GAPID_DEBUG("glCullFace() -- done");
    }
}
EXPORT void STDCALL glDepthRangef(GLfloat near, GLfloat far) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangef(%f, %f)", near, far);
    if (s->enter("glDepthRangef")) {
        s->glDepthRangef(near, far);
        s->exit();
        GAPID_DEBUG("glDepthRangef() -- done");
    } else {
        GAPID_INFO("glDepthRangef at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangef, s->GlesSpy::imports().glDepthRangef);
        s->GlesSpy::imports().glDepthRangef(near, far);
        GAPID_DEBUG("glDepthRangef() -- done");
    }
}
EXPORT void STDCALL glFrontFace(uint32_t orientation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFrontFace(%u)", orientation);
    if (s->enter("glFrontFace")) {
        s->glFrontFace(orientation);
        s->exit();
        GAPID_DEBUG("glFrontFace() -- done");
    } else {
        GAPID_INFO("glFrontFace at %p: GAPII re-entered. Just invoking imported function at %p", glFrontFace, s->GlesSpy::imports().glFrontFace);
        s->GlesSpy::imports().glFrontFace(orientation);
        GAPID_DEBUG("glFrontFace() -- done");
    }
}
EXPORT void STDCALL glGetMultisamplefv(uint32_t pname, GLuint index, GLfloat* val) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetMultisamplefv(%u, %" PRIu32 ", %p)", pname, index, val);
    if (s->enter("glGetMultisamplefv")) {
        s->glGetMultisamplefv(pname, index, val);
        s->exit();
        GAPID_DEBUG("glGetMultisamplefv() -- done");
    } else {
        GAPID_INFO("glGetMultisamplefv at %p: GAPII re-entered. Just invoking imported function at %p", glGetMultisamplefv, s->GlesSpy::imports().glGetMultisamplefv);
        s->GlesSpy::imports().glGetMultisamplefv(pname, index, val);
        GAPID_DEBUG("glGetMultisamplefv() -- done");
    }
}
EXPORT void STDCALL glLineWidth(GLfloat width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLineWidth(%f)", width);
    if (s->enter("glLineWidth")) {
        s->glLineWidth(width);
        s->exit();
        GAPID_DEBUG("glLineWidth() -- done");
    } else {
        GAPID_INFO("glLineWidth at %p: GAPII re-entered. Just invoking imported function at %p", glLineWidth, s->GlesSpy::imports().glLineWidth);
        s->GlesSpy::imports().glLineWidth(width);
        GAPID_DEBUG("glLineWidth() -- done");
    }
}
EXPORT void STDCALL glMinSampleShading(GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMinSampleShading(%f)", value);
    if (s->enter("glMinSampleShading")) {
        s->glMinSampleShading(value);
        s->exit();
        GAPID_DEBUG("glMinSampleShading() -- done");
    } else {
        GAPID_INFO("glMinSampleShading at %p: GAPII re-entered. Just invoking imported function at %p", glMinSampleShading, s->GlesSpy::imports().glMinSampleShading);
        s->GlesSpy::imports().glMinSampleShading(value);
        GAPID_DEBUG("glMinSampleShading() -- done");
    }
}
EXPORT void STDCALL glPolygonOffset(GLfloat scale_factor, GLfloat units) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPolygonOffset(%f, %f)", scale_factor, units);
    if (s->enter("glPolygonOffset")) {
        s->glPolygonOffset(scale_factor, units);
        s->exit();
        GAPID_DEBUG("glPolygonOffset() -- done");
    } else {
        GAPID_INFO("glPolygonOffset at %p: GAPII re-entered. Just invoking imported function at %p", glPolygonOffset, s->GlesSpy::imports().glPolygonOffset);
        s->GlesSpy::imports().glPolygonOffset(scale_factor, units);
        GAPID_DEBUG("glPolygonOffset() -- done");
    }
}
EXPORT void STDCALL glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewport(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, width, height);
    if (s->enter("glViewport")) {
        s->glViewport(x, y, width, height);
        s->exit();
        GAPID_DEBUG("glViewport() -- done");
    } else {
        GAPID_INFO("glViewport at %p: GAPII re-entered. Just invoking imported function at %p", glViewport, s->GlesSpy::imports().glViewport);
        s->GlesSpy::imports().glViewport(x, y, width, height);
        GAPID_DEBUG("glViewport() -- done");
    }
}
EXPORT void STDCALL glGetBooleani_v(uint32_t param, GLuint index, GLboolean* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetBooleani_v(%u, %" PRIu32 ", %p)", param, index, values);
    if (s->enter("glGetBooleani_v")) {
        s->glGetBooleani_v(param, index, values);
        s->exit();
        GAPID_DEBUG("glGetBooleani_v() -- done");
    } else {
        GAPID_INFO("glGetBooleani_v at %p: GAPII re-entered. Just invoking imported function at %p", glGetBooleani_v, s->GlesSpy::imports().glGetBooleani_v);
        s->GlesSpy::imports().glGetBooleani_v(param, index, values);
        GAPID_DEBUG("glGetBooleani_v() -- done");
    }
}
EXPORT void STDCALL glGetBooleanv(uint32_t param, GLboolean* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetBooleanv(%u, %p)", param, values);
    if (s->enter("glGetBooleanv")) {
        s->glGetBooleanv(param, values);
        s->exit();
        GAPID_DEBUG("glGetBooleanv() -- done");
    } else {
        GAPID_INFO("glGetBooleanv at %p: GAPII re-entered. Just invoking imported function at %p", glGetBooleanv, s->GlesSpy::imports().glGetBooleanv);
        s->GlesSpy::imports().glGetBooleanv(param, values);
        GAPID_DEBUG("glGetBooleanv() -- done");
    }
}
EXPORT void STDCALL glGetFloatv(uint32_t param, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFloatv(%u, %p)", param, values);
    if (s->enter("glGetFloatv")) {
        s->glGetFloatv(param, values);
        s->exit();
        GAPID_DEBUG("glGetFloatv() -- done");
    } else {
        GAPID_INFO("glGetFloatv at %p: GAPII re-entered. Just invoking imported function at %p", glGetFloatv, s->GlesSpy::imports().glGetFloatv);
        s->GlesSpy::imports().glGetFloatv(param, values);
        GAPID_DEBUG("glGetFloatv() -- done");
    }
}
EXPORT void STDCALL glGetInteger64i_v(uint32_t param, GLuint index, GLint64* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetInteger64i_v(%u, %" PRIu32 ", %p)", param, index, values);
    if (s->enter("glGetInteger64i_v")) {
        s->glGetInteger64i_v(param, index, values);
        s->exit();
        GAPID_DEBUG("glGetInteger64i_v() -- done");
    } else {
        GAPID_INFO("glGetInteger64i_v at %p: GAPII re-entered. Just invoking imported function at %p", glGetInteger64i_v, s->GlesSpy::imports().glGetInteger64i_v);
        s->GlesSpy::imports().glGetInteger64i_v(param, index, values);
        GAPID_DEBUG("glGetInteger64i_v() -- done");
    }
}
EXPORT void STDCALL glGetInteger64v(uint32_t param, GLint64* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetInteger64v(%u, %p)", param, values);
    if (s->enter("glGetInteger64v")) {
        s->glGetInteger64v(param, values);
        s->exit();
        GAPID_DEBUG("glGetInteger64v() -- done");
    } else {
        GAPID_INFO("glGetInteger64v at %p: GAPII re-entered. Just invoking imported function at %p", glGetInteger64v, s->GlesSpy::imports().glGetInteger64v);
        s->GlesSpy::imports().glGetInteger64v(param, values);
        GAPID_DEBUG("glGetInteger64v() -- done");
    }
}
EXPORT void STDCALL glGetIntegeri_v(uint32_t param, GLuint index, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetIntegeri_v(%u, %" PRIu32 ", %p)", param, index, values);
    if (s->enter("glGetIntegeri_v")) {
        s->glGetIntegeri_v(param, index, values);
        s->exit();
        GAPID_DEBUG("glGetIntegeri_v() -- done");
    } else {
        GAPID_INFO("glGetIntegeri_v at %p: GAPII re-entered. Just invoking imported function at %p", glGetIntegeri_v, s->GlesSpy::imports().glGetIntegeri_v);
        s->GlesSpy::imports().glGetIntegeri_v(param, index, values);
        GAPID_DEBUG("glGetIntegeri_v() -- done");
    }
}
EXPORT void STDCALL glGetIntegerv(uint32_t param, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetIntegerv(%u, %p)", param, values);
    if (s->enter("glGetIntegerv")) {
        s->glGetIntegerv(param, values);
        s->exit();
        GAPID_DEBUG("glGetIntegerv() -- done");
    } else {
        GAPID_INFO("glGetIntegerv at %p: GAPII re-entered. Just invoking imported function at %p", glGetIntegerv, s->GlesSpy::imports().glGetIntegerv);
        s->GlesSpy::imports().glGetIntegerv(param, values);
        GAPID_DEBUG("glGetIntegerv() -- done");
    }
}
EXPORT void STDCALL glGetInternalformativ(uint32_t target, uint32_t internalformat, uint32_t pname, GLsizei bufSize, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetInternalformativ(%u, %u, %u, %" PRId32 ", %p)", target, internalformat, pname, bufSize, params);
    if (s->enter("glGetInternalformativ")) {
        s->glGetInternalformativ(target, internalformat, pname, bufSize, params);
        s->exit();
        GAPID_DEBUG("glGetInternalformativ() -- done");
    } else {
        GAPID_INFO("glGetInternalformativ at %p: GAPII re-entered. Just invoking imported function at %p", glGetInternalformativ, s->GlesSpy::imports().glGetInternalformativ);
        s->GlesSpy::imports().glGetInternalformativ(target, internalformat, pname, bufSize, params);
        GAPID_DEBUG("glGetInternalformativ() -- done");
    }
}
EXPORT GLubyte* STDCALL glGetString(uint32_t param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetString(%u)", param);
    if (s->enter("glGetString")) {
        auto _result_ = s->glGetString(param);
        s->exit();
        GAPID_DEBUG("glGetString() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetString at %p: GAPII re-entered. Just invoking imported function at %p", glGetString, s->GlesSpy::imports().glGetString);
        auto _result_ = s->GlesSpy::imports().glGetString(param);
        GAPID_DEBUG("glGetString() -- done");
        return _result_;
    }
}
EXPORT GLubyte* STDCALL glGetStringi(uint32_t name, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetStringi(%u, %" PRIu32 ")", name, index);
    if (s->enter("glGetStringi")) {
        auto _result_ = s->glGetStringi(name, index);
        s->exit();
        GAPID_DEBUG("glGetStringi() -- done");
        return _result_;
    } else {
        GAPID_INFO("glGetStringi at %p: GAPII re-entered. Just invoking imported function at %p", glGetStringi, s->GlesSpy::imports().glGetStringi);
        auto _result_ = s->GlesSpy::imports().glGetStringi(name, index);
        GAPID_DEBUG("glGetStringi() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsEnabled(uint32_t capability) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsEnabled(%u)", capability);
    if (s->enter("glIsEnabled")) {
        auto _result_ = s->glIsEnabled(capability);
        s->exit();
        GAPID_DEBUG("glIsEnabled() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsEnabled at %p: GAPII re-entered. Just invoking imported function at %p", glIsEnabled, s->GlesSpy::imports().glIsEnabled);
        auto _result_ = s->GlesSpy::imports().glIsEnabled(capability);
        GAPID_DEBUG("glIsEnabled() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsEnabledi(uint32_t capability, GLuint index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsEnabledi(%u, %" PRIu32 ")", capability, index);
    if (s->enter("glIsEnabledi")) {
        auto _result_ = s->glIsEnabledi(capability, index);
        s->exit();
        GAPID_DEBUG("glIsEnabledi() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsEnabledi at %p: GAPII re-entered. Just invoking imported function at %p", glIsEnabledi, s->GlesSpy::imports().glIsEnabledi);
        auto _result_ = s->GlesSpy::imports().glIsEnabledi(capability, index);
        GAPID_DEBUG("glIsEnabledi() -- done");
        return _result_;
    }
}
EXPORT uint32_t STDCALL glClientWaitSync(GLsync sync, uint32_t syncFlags, GLuint64 timeout) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClientWaitSync(%p, %u, %" PRIu64 ")", sync, syncFlags, timeout);
    if (s->enter("glClientWaitSync")) {
        auto _result_ = s->glClientWaitSync(sync, syncFlags, timeout);
        s->exit();
        GAPID_DEBUG("glClientWaitSync() -- done");
        return _result_;
    } else {
        GAPID_INFO("glClientWaitSync at %p: GAPII re-entered. Just invoking imported function at %p", glClientWaitSync, s->GlesSpy::imports().glClientWaitSync);
        auto _result_ = s->GlesSpy::imports().glClientWaitSync(sync, syncFlags, timeout);
        GAPID_DEBUG("glClientWaitSync() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glDeleteSync(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteSync(%p)", sync);
    if (s->enter("glDeleteSync")) {
        s->glDeleteSync(sync);
        s->exit();
        GAPID_DEBUG("glDeleteSync() -- done");
    } else {
        GAPID_INFO("glDeleteSync at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteSync, s->GlesSpy::imports().glDeleteSync);
        s->GlesSpy::imports().glDeleteSync(sync);
        GAPID_DEBUG("glDeleteSync() -- done");
    }
}
EXPORT GLsync STDCALL glFenceSync(uint32_t condition, uint32_t syncFlags) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFenceSync(%u, %u)", condition, syncFlags);
    if (s->enter("glFenceSync")) {
        auto _result_ = s->glFenceSync(condition, syncFlags);
        s->exit();
        GAPID_DEBUG("glFenceSync() -- done");
        return _result_;
    } else {
        GAPID_INFO("glFenceSync at %p: GAPII re-entered. Just invoking imported function at %p", glFenceSync, s->GlesSpy::imports().glFenceSync);
        auto _result_ = s->GlesSpy::imports().glFenceSync(condition, syncFlags);
        GAPID_DEBUG("glFenceSync() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetSynciv(GLsync sync, uint32_t pname, GLsizei bufSize, GLsizei* length, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSynciv(%p, %u, %" PRId32 ", %p, %p)", sync, pname, bufSize, length, values);
    if (s->enter("glGetSynciv")) {
        s->glGetSynciv(sync, pname, bufSize, length, values);
        s->exit();
        GAPID_DEBUG("glGetSynciv() -- done");
    } else {
        GAPID_INFO("glGetSynciv at %p: GAPII re-entered. Just invoking imported function at %p", glGetSynciv, s->GlesSpy::imports().glGetSynciv);
        s->GlesSpy::imports().glGetSynciv(sync, pname, bufSize, length, values);
        GAPID_DEBUG("glGetSynciv() -- done");
    }
}
EXPORT GLboolean STDCALL glIsSync(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsSync(%p)", sync);
    if (s->enter("glIsSync")) {
        auto _result_ = s->glIsSync(sync);
        s->exit();
        GAPID_DEBUG("glIsSync() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsSync at %p: GAPII re-entered. Just invoking imported function at %p", glIsSync, s->GlesSpy::imports().glIsSync);
        auto _result_ = s->GlesSpy::imports().glIsSync(sync);
        GAPID_DEBUG("glIsSync() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glWaitSync(GLsync sync, uint32_t syncFlags, GLuint64 timeout) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glWaitSync(%p, %u, %" PRIu64 ")", sync, syncFlags, timeout);
    if (s->enter("glWaitSync")) {
        s->glWaitSync(sync, syncFlags, timeout);
        s->exit();
        GAPID_DEBUG("glWaitSync() -- done");
    } else {
        GAPID_INFO("glWaitSync at %p: GAPII re-entered. Just invoking imported function at %p", glWaitSync, s->GlesSpy::imports().glWaitSync);
        s->GlesSpy::imports().glWaitSync(sync, syncFlags, timeout);
        GAPID_DEBUG("glWaitSync() -- done");
    }
}
EXPORT void STDCALL glActiveTexture(uint32_t unit) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glActiveTexture(%u)", unit);
    if (s->enter("glActiveTexture")) {
        s->glActiveTexture(unit);
        s->exit();
        GAPID_DEBUG("glActiveTexture() -- done");
    } else {
        GAPID_INFO("glActiveTexture at %p: GAPII re-entered. Just invoking imported function at %p", glActiveTexture, s->GlesSpy::imports().glActiveTexture);
        s->GlesSpy::imports().glActiveTexture(unit);
        GAPID_DEBUG("glActiveTexture() -- done");
    }
}
EXPORT void STDCALL glBindImageTexture(GLuint unit, TextureId texture, GLint level, GLboolean layered, GLint layer, uint32_t access, uint32_t format) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindImageTexture(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRIu8 ", %" PRId32 ", %u, %u)", unit, texture, level, layered, layer, access, format);
    if (s->enter("glBindImageTexture")) {
        s->glBindImageTexture(unit, texture, level, layered, layer, access, format);
        s->exit();
        GAPID_DEBUG("glBindImageTexture() -- done");
    } else {
        GAPID_INFO("glBindImageTexture at %p: GAPII re-entered. Just invoking imported function at %p", glBindImageTexture, s->GlesSpy::imports().glBindImageTexture);
        s->GlesSpy::imports().glBindImageTexture(unit, texture, level, layered, layer, access, format);
        GAPID_DEBUG("glBindImageTexture() -- done");
    }
}
EXPORT void STDCALL glBindSampler(GLuint index, SamplerId sampler) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindSampler(%" PRIu32 ", %" PRIu32 ")", index, sampler);
    if (s->enter("glBindSampler")) {
        s->glBindSampler(index, sampler);
        s->exit();
        GAPID_DEBUG("glBindSampler() -- done");
    } else {
        GAPID_INFO("glBindSampler at %p: GAPII re-entered. Just invoking imported function at %p", glBindSampler, s->GlesSpy::imports().glBindSampler);
        s->GlesSpy::imports().glBindSampler(index, sampler);
        GAPID_DEBUG("glBindSampler() -- done");
    }
}
EXPORT void STDCALL glBindTexture(uint32_t target, TextureId texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindTexture(%u, %" PRIu32 ")", target, texture);
    if (s->enter("glBindTexture")) {
        s->glBindTexture(target, texture);
        s->exit();
        GAPID_DEBUG("glBindTexture() -- done");
    } else {
        GAPID_INFO("glBindTexture at %p: GAPII re-entered. Just invoking imported function at %p", glBindTexture, s->GlesSpy::imports().glBindTexture);
        s->GlesSpy::imports().glBindTexture(target, texture);
        GAPID_DEBUG("glBindTexture() -- done");
    }
}
EXPORT void STDCALL glCompressedTexImage2D(uint32_t target, GLint level, uint32_t format, GLsizei width, GLsizei height, GLint border, GLsizei image_size, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompressedTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)", target, level, format, width, height, border, image_size, data);
    if (s->enter("glCompressedTexImage2D")) {
        s->glCompressedTexImage2D(target, level, format, width, height, border, image_size, data);
        s->exit();
        GAPID_DEBUG("glCompressedTexImage2D() -- done");
    } else {
        GAPID_INFO("glCompressedTexImage2D at %p: GAPII re-entered. Just invoking imported function at %p", glCompressedTexImage2D, s->GlesSpy::imports().glCompressedTexImage2D);
        s->GlesSpy::imports().glCompressedTexImage2D(target, level, format, width, height, border, image_size, data);
        GAPID_DEBUG("glCompressedTexImage2D() -- done");
    }
}
EXPORT void STDCALL glCompressedTexImage3D(uint32_t target, GLint level, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei image_size, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompressedTexImage3D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)", target, level, internalformat, width, height, depth, border, image_size, data);
    if (s->enter("glCompressedTexImage3D")) {
        s->glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, image_size, data);
        s->exit();
        GAPID_DEBUG("glCompressedTexImage3D() -- done");
    } else {
        GAPID_INFO("glCompressedTexImage3D at %p: GAPII re-entered. Just invoking imported function at %p", glCompressedTexImage3D, s->GlesSpy::imports().glCompressedTexImage3D);
        s->GlesSpy::imports().glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, image_size, data);
        GAPID_DEBUG("glCompressedTexImage3D() -- done");
    }
}
EXPORT void STDCALL glCompressedTexSubImage2D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, uint32_t format, GLsizei image_size, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompressedTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %" PRId32 ", %p)", target, level, xoffset, yoffset, width, height, format, image_size, data);
    if (s->enter("glCompressedTexSubImage2D")) {
        s->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, image_size, data);
        s->exit();
        GAPID_DEBUG("glCompressedTexSubImage2D() -- done");
    } else {
        GAPID_INFO("glCompressedTexSubImage2D at %p: GAPII re-entered. Just invoking imported function at %p", glCompressedTexSubImage2D, s->GlesSpy::imports().glCompressedTexSubImage2D);
        s->GlesSpy::imports().glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, image_size, data);
        GAPID_DEBUG("glCompressedTexSubImage2D() -- done");
    }
}
EXPORT void STDCALL glCompressedTexSubImage3D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, GLsizei image_size, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompressedTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %" PRId32 ", %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
    if (s->enter("glCompressedTexSubImage3D")) {
        s->glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
        s->exit();
        GAPID_DEBUG("glCompressedTexSubImage3D() -- done");
    } else {
        GAPID_INFO("glCompressedTexSubImage3D at %p: GAPII re-entered. Just invoking imported function at %p", glCompressedTexSubImage3D, s->GlesSpy::imports().glCompressedTexSubImage3D);
        s->GlesSpy::imports().glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
        GAPID_DEBUG("glCompressedTexSubImage3D() -- done");
    }
}
EXPORT void STDCALL glCopyImageSubData(GLuint srcName, uint32_t srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, uint32_t dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyImageSubData(%" PRIu32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
    if (s->enter("glCopyImageSubData")) {
        s->glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        s->exit();
        GAPID_DEBUG("glCopyImageSubData() -- done");
    } else {
        GAPID_INFO("glCopyImageSubData at %p: GAPII re-entered. Just invoking imported function at %p", glCopyImageSubData, s->GlesSpy::imports().glCopyImageSubData);
        s->GlesSpy::imports().glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        GAPID_DEBUG("glCopyImageSubData() -- done");
    }
}
EXPORT void STDCALL glCopyTexImage2D(uint32_t target, GLint level, uint32_t format, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, format, x, y, width, height, border);
    if (s->enter("glCopyTexImage2D")) {
        s->glCopyTexImage2D(target, level, format, x, y, width, height, border);
        s->exit();
        GAPID_DEBUG("glCopyTexImage2D() -- done");
    } else {
        GAPID_INFO("glCopyTexImage2D at %p: GAPII re-entered. Just invoking imported function at %p", glCopyTexImage2D, s->GlesSpy::imports().glCopyTexImage2D);
        s->GlesSpy::imports().glCopyTexImage2D(target, level, format, x, y, width, height, border);
        GAPID_DEBUG("glCopyTexImage2D() -- done");
    }
}
EXPORT void STDCALL glCopyTexSubImage2D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, xoffset, yoffset, x, y, width, height);
    if (s->enter("glCopyTexSubImage2D")) {
        s->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
        s->exit();
        GAPID_DEBUG("glCopyTexSubImage2D() -- done");
    } else {
        GAPID_INFO("glCopyTexSubImage2D at %p: GAPII re-entered. Just invoking imported function at %p", glCopyTexSubImage2D, s->GlesSpy::imports().glCopyTexSubImage2D);
        s->GlesSpy::imports().glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
        GAPID_DEBUG("glCopyTexSubImage2D() -- done");
    }
}
EXPORT void STDCALL glCopyTexSubImage3D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCopyTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, xoffset, yoffset, zoffset, x, y, width, height);
    if (s->enter("glCopyTexSubImage3D")) {
        s->glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
        s->exit();
        GAPID_DEBUG("glCopyTexSubImage3D() -- done");
    } else {
        GAPID_INFO("glCopyTexSubImage3D at %p: GAPII re-entered. Just invoking imported function at %p", glCopyTexSubImage3D, s->GlesSpy::imports().glCopyTexSubImage3D);
        s->GlesSpy::imports().glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
        GAPID_DEBUG("glCopyTexSubImage3D() -- done");
    }
}
EXPORT void STDCALL glDeleteSamplers(GLsizei count, SamplerId* samplers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteSamplers(%" PRId32 ", %p)", count, samplers);
    if (s->enter("glDeleteSamplers")) {
        s->glDeleteSamplers(count, samplers);
        s->exit();
        GAPID_DEBUG("glDeleteSamplers() -- done");
    } else {
        GAPID_INFO("glDeleteSamplers at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteSamplers, s->GlesSpy::imports().glDeleteSamplers);
        s->GlesSpy::imports().glDeleteSamplers(count, samplers);
        GAPID_DEBUG("glDeleteSamplers() -- done");
    }
}
EXPORT void STDCALL glDeleteTextures(GLsizei count, TextureId* textures) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteTextures(%" PRId32 ", %p)", count, textures);
    if (s->enter("glDeleteTextures")) {
        s->glDeleteTextures(count, textures);
        s->exit();
        GAPID_DEBUG("glDeleteTextures() -- done");
    } else {
        GAPID_INFO("glDeleteTextures at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteTextures, s->GlesSpy::imports().glDeleteTextures);
        s->GlesSpy::imports().glDeleteTextures(count, textures);
        GAPID_DEBUG("glDeleteTextures() -- done");
    }
}
EXPORT void STDCALL glGenSamplers(GLsizei count, SamplerId* samplers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenSamplers(%" PRId32 ", %p)", count, samplers);
    if (s->enter("glGenSamplers")) {
        s->glGenSamplers(count, samplers);
        s->exit();
        GAPID_DEBUG("glGenSamplers() -- done");
    } else {
        GAPID_INFO("glGenSamplers at %p: GAPII re-entered. Just invoking imported function at %p", glGenSamplers, s->GlesSpy::imports().glGenSamplers);
        s->GlesSpy::imports().glGenSamplers(count, samplers);
        GAPID_DEBUG("glGenSamplers() -- done");
    }
}
EXPORT void STDCALL glGenTextures(GLsizei count, TextureId* textures) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenTextures(%" PRId32 ", %p)", count, textures);
    if (s->enter("glGenTextures")) {
        s->glGenTextures(count, textures);
        s->exit();
        GAPID_DEBUG("glGenTextures() -- done");
    } else {
        GAPID_INFO("glGenTextures at %p: GAPII re-entered. Just invoking imported function at %p", glGenTextures, s->GlesSpy::imports().glGenTextures);
        s->GlesSpy::imports().glGenTextures(count, textures);
        GAPID_DEBUG("glGenTextures() -- done");
    }
}
EXPORT void STDCALL glGenerateMipmap(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenerateMipmap(%u)", target);
    if (s->enter("glGenerateMipmap")) {
        s->glGenerateMipmap(target);
        s->exit();
        GAPID_DEBUG("glGenerateMipmap() -- done");
    } else {
        GAPID_INFO("glGenerateMipmap at %p: GAPII re-entered. Just invoking imported function at %p", glGenerateMipmap, s->GlesSpy::imports().glGenerateMipmap);
        s->GlesSpy::imports().glGenerateMipmap(target);
        GAPID_DEBUG("glGenerateMipmap() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterIiv(SamplerId sampler, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterIiv(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterIiv")) {
        s->glGetSamplerParameterIiv(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterIiv() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterIiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterIiv, s->GlesSpy::imports().glGetSamplerParameterIiv);
        s->GlesSpy::imports().glGetSamplerParameterIiv(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterIiv() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterIuiv(SamplerId sampler, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterIuiv(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterIuiv")) {
        s->glGetSamplerParameterIuiv(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterIuiv() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterIuiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterIuiv, s->GlesSpy::imports().glGetSamplerParameterIuiv);
        s->GlesSpy::imports().glGetSamplerParameterIuiv(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterIuiv() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameterfv(SamplerId sampler, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameterfv(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameterfv")) {
        s->glGetSamplerParameterfv(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameterfv() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameterfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameterfv, s->GlesSpy::imports().glGetSamplerParameterfv);
        s->GlesSpy::imports().glGetSamplerParameterfv(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameterfv() -- done");
    }
}
EXPORT void STDCALL glGetSamplerParameteriv(SamplerId sampler, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetSamplerParameteriv(%" PRIu32 ", %u, %p)", sampler, pname, params);
    if (s->enter("glGetSamplerParameteriv")) {
        s->glGetSamplerParameteriv(sampler, pname, params);
        s->exit();
        GAPID_DEBUG("glGetSamplerParameteriv() -- done");
    } else {
        GAPID_INFO("glGetSamplerParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetSamplerParameteriv, s->GlesSpy::imports().glGetSamplerParameteriv);
        s->GlesSpy::imports().glGetSamplerParameteriv(sampler, pname, params);
        GAPID_DEBUG("glGetSamplerParameteriv() -- done");
    }
}
EXPORT void STDCALL glGetTexLevelParameterfv(uint32_t target, GLint level, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexLevelParameterfv(%u, %" PRId32 ", %u, %p)", target, level, pname, params);
    if (s->enter("glGetTexLevelParameterfv")) {
        s->glGetTexLevelParameterfv(target, level, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexLevelParameterfv() -- done");
    } else {
        GAPID_INFO("glGetTexLevelParameterfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexLevelParameterfv, s->GlesSpy::imports().glGetTexLevelParameterfv);
        s->GlesSpy::imports().glGetTexLevelParameterfv(target, level, pname, params);
        GAPID_DEBUG("glGetTexLevelParameterfv() -- done");
    }
}
EXPORT void STDCALL glGetTexLevelParameteriv(uint32_t target, GLint level, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexLevelParameteriv(%u, %" PRId32 ", %u, %p)", target, level, pname, params);
    if (s->enter("glGetTexLevelParameteriv")) {
        s->glGetTexLevelParameteriv(target, level, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexLevelParameteriv() -- done");
    } else {
        GAPID_INFO("glGetTexLevelParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexLevelParameteriv, s->GlesSpy::imports().glGetTexLevelParameteriv);
        s->GlesSpy::imports().glGetTexLevelParameteriv(target, level, pname, params);
        GAPID_DEBUG("glGetTexLevelParameteriv() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterIiv(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterIiv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterIiv")) {
        s->glGetTexParameterIiv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterIiv() -- done");
    } else {
        GAPID_INFO("glGetTexParameterIiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterIiv, s->GlesSpy::imports().glGetTexParameterIiv);
        s->GlesSpy::imports().glGetTexParameterIiv(target, pname, params);
        GAPID_DEBUG("glGetTexParameterIiv() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterIuiv(uint32_t target, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterIuiv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterIuiv")) {
        s->glGetTexParameterIuiv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterIuiv() -- done");
    } else {
        GAPID_INFO("glGetTexParameterIuiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterIuiv, s->GlesSpy::imports().glGetTexParameterIuiv);
        s->GlesSpy::imports().glGetTexParameterIuiv(target, pname, params);
        GAPID_DEBUG("glGetTexParameterIuiv() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterfv(uint32_t target, uint32_t parameter, GLfloat* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterfv(%u, %u, %p)", target, parameter, values);
    if (s->enter("glGetTexParameterfv")) {
        s->glGetTexParameterfv(target, parameter, values);
        s->exit();
        GAPID_DEBUG("glGetTexParameterfv() -- done");
    } else {
        GAPID_INFO("glGetTexParameterfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterfv, s->GlesSpy::imports().glGetTexParameterfv);
        s->GlesSpy::imports().glGetTexParameterfv(target, parameter, values);
        GAPID_DEBUG("glGetTexParameterfv() -- done");
    }
}
EXPORT void STDCALL glGetTexParameteriv(uint32_t target, uint32_t parameter, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameteriv(%u, %u, %p)", target, parameter, values);
    if (s->enter("glGetTexParameteriv")) {
        s->glGetTexParameteriv(target, parameter, values);
        s->exit();
        GAPID_DEBUG("glGetTexParameteriv() -- done");
    } else {
        GAPID_INFO("glGetTexParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameteriv, s->GlesSpy::imports().glGetTexParameteriv);
        s->GlesSpy::imports().glGetTexParameteriv(target, parameter, values);
        GAPID_DEBUG("glGetTexParameteriv() -- done");
    }
}
EXPORT GLboolean STDCALL glIsSampler(SamplerId sampler) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsSampler(%" PRIu32 ")", sampler);
    if (s->enter("glIsSampler")) {
        auto _result_ = s->glIsSampler(sampler);
        s->exit();
        GAPID_DEBUG("glIsSampler() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsSampler at %p: GAPII re-entered. Just invoking imported function at %p", glIsSampler, s->GlesSpy::imports().glIsSampler);
        auto _result_ = s->GlesSpy::imports().glIsSampler(sampler);
        GAPID_DEBUG("glIsSampler() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsTexture(TextureId texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsTexture(%" PRIu32 ")", texture);
    if (s->enter("glIsTexture")) {
        auto _result_ = s->glIsTexture(texture);
        s->exit();
        GAPID_DEBUG("glIsTexture() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsTexture at %p: GAPII re-entered. Just invoking imported function at %p", glIsTexture, s->GlesSpy::imports().glIsTexture);
        auto _result_ = s->GlesSpy::imports().glIsTexture(texture);
        GAPID_DEBUG("glIsTexture() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glPixelStorei(uint32_t parameter, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPixelStorei(%u, %" PRId32 ")", parameter, value);
    if (s->enter("glPixelStorei")) {
        s->glPixelStorei(parameter, value);
        s->exit();
        GAPID_DEBUG("glPixelStorei() -- done");
    } else {
        GAPID_INFO("glPixelStorei at %p: GAPII re-entered. Just invoking imported function at %p", glPixelStorei, s->GlesSpy::imports().glPixelStorei);
        s->GlesSpy::imports().glPixelStorei(parameter, value);
        GAPID_DEBUG("glPixelStorei() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterIiv(SamplerId sampler, uint32_t pname, GLint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterIiv(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterIiv")) {
        s->glSamplerParameterIiv(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterIiv() -- done");
    } else {
        GAPID_INFO("glSamplerParameterIiv at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterIiv, s->GlesSpy::imports().glSamplerParameterIiv);
        s->GlesSpy::imports().glSamplerParameterIiv(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterIiv() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterIuiv(SamplerId sampler, uint32_t pname, GLuint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterIuiv(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterIuiv")) {
        s->glSamplerParameterIuiv(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterIuiv() -- done");
    } else {
        GAPID_INFO("glSamplerParameterIuiv at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterIuiv, s->GlesSpy::imports().glSamplerParameterIuiv);
        s->GlesSpy::imports().glSamplerParameterIuiv(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterIuiv() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterf(SamplerId sampler, uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterf(%" PRIu32 ", %u, %f)", sampler, pname, param);
    if (s->enter("glSamplerParameterf")) {
        s->glSamplerParameterf(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterf() -- done");
    } else {
        GAPID_INFO("glSamplerParameterf at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterf, s->GlesSpy::imports().glSamplerParameterf);
        s->GlesSpy::imports().glSamplerParameterf(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterf() -- done");
    }
}
EXPORT void STDCALL glSamplerParameterfv(SamplerId sampler, uint32_t pname, GLfloat* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameterfv(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameterfv")) {
        s->glSamplerParameterfv(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameterfv() -- done");
    } else {
        GAPID_INFO("glSamplerParameterfv at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameterfv, s->GlesSpy::imports().glSamplerParameterfv);
        s->GlesSpy::imports().glSamplerParameterfv(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameterfv() -- done");
    }
}
EXPORT void STDCALL glSamplerParameteri(SamplerId sampler, uint32_t pname, GLint param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameteri(%" PRIu32 ", %u, %" PRId32 ")", sampler, pname, param);
    if (s->enter("glSamplerParameteri")) {
        s->glSamplerParameteri(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameteri() -- done");
    } else {
        GAPID_INFO("glSamplerParameteri at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameteri, s->GlesSpy::imports().glSamplerParameteri);
        s->GlesSpy::imports().glSamplerParameteri(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameteri() -- done");
    }
}
EXPORT void STDCALL glSamplerParameteriv(SamplerId sampler, uint32_t pname, GLint* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSamplerParameteriv(%" PRIu32 ", %u, %p)", sampler, pname, param);
    if (s->enter("glSamplerParameteriv")) {
        s->glSamplerParameteriv(sampler, pname, param);
        s->exit();
        GAPID_DEBUG("glSamplerParameteriv() -- done");
    } else {
        GAPID_INFO("glSamplerParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glSamplerParameteriv, s->GlesSpy::imports().glSamplerParameteriv);
        s->GlesSpy::imports().glSamplerParameteriv(sampler, pname, param);
        GAPID_DEBUG("glSamplerParameteriv() -- done");
    }
}
EXPORT void STDCALL glTexBuffer(uint32_t target, uint32_t internalformat, BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexBuffer(%u, %u, %" PRIu32 ")", target, internalformat, buffer);
    if (s->enter("glTexBuffer")) {
        s->glTexBuffer(target, internalformat, buffer);
        s->exit();
        GAPID_DEBUG("glTexBuffer() -- done");
    } else {
        GAPID_INFO("glTexBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glTexBuffer, s->GlesSpy::imports().glTexBuffer);
        s->GlesSpy::imports().glTexBuffer(target, internalformat, buffer);
        GAPID_DEBUG("glTexBuffer() -- done");
    }
}
EXPORT void STDCALL glTexBufferRange(uint32_t target, uint32_t internalformat, BufferId buffer, GLintptr offset, GLsizeiptr size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexBufferRange(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, internalformat, buffer, offset, size);
    if (s->enter("glTexBufferRange")) {
        s->glTexBufferRange(target, internalformat, buffer, offset, size);
        s->exit();
        GAPID_DEBUG("glTexBufferRange() -- done");
    } else {
        GAPID_INFO("glTexBufferRange at %p: GAPII re-entered. Just invoking imported function at %p", glTexBufferRange, s->GlesSpy::imports().glTexBufferRange);
        s->GlesSpy::imports().glTexBufferRange(target, internalformat, buffer, offset, size);
        GAPID_DEBUG("glTexBufferRange() -- done");
    }
}
EXPORT void STDCALL glTexImage2D(uint32_t target, GLint level, GLint internal_format, GLsizei width, GLsizei height, GLint border, uint32_t format, uint32_t type, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, internal_format, width, height, border, format, type, data);
    if (s->enter("glTexImage2D")) {
        s->glTexImage2D(target, level, internal_format, width, height, border, format, type, data);
        s->exit();
        GAPID_DEBUG("glTexImage2D() -- done");
    } else {
        GAPID_INFO("glTexImage2D at %p: GAPII re-entered. Just invoking imported function at %p", glTexImage2D, s->GlesSpy::imports().glTexImage2D);
        s->GlesSpy::imports().glTexImage2D(target, level, internal_format, width, height, border, format, type, data);
        GAPID_DEBUG("glTexImage2D() -- done");
    }
}
EXPORT void STDCALL glTexImage3D(uint32_t target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, uint32_t format, uint32_t type, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, internalformat, width, height, depth, border, format, type, data);
    if (s->enter("glTexImage3D")) {
        s->glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, data);
        s->exit();
        GAPID_DEBUG("glTexImage3D() -- done");
    } else {
        GAPID_INFO("glTexImage3D at %p: GAPII re-entered. Just invoking imported function at %p", glTexImage3D, s->GlesSpy::imports().glTexImage3D);
        s->GlesSpy::imports().glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, data);
        GAPID_DEBUG("glTexImage3D() -- done");
    }
}
EXPORT void STDCALL glTexParameterIiv(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterIiv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterIiv")) {
        s->glTexParameterIiv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterIiv() -- done");
    } else {
        GAPID_INFO("glTexParameterIiv at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterIiv, s->GlesSpy::imports().glTexParameterIiv);
        s->GlesSpy::imports().glTexParameterIiv(target, pname, params);
        GAPID_DEBUG("glTexParameterIiv() -- done");
    }
}
EXPORT void STDCALL glTexParameterIuiv(uint32_t target, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterIuiv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterIuiv")) {
        s->glTexParameterIuiv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterIuiv() -- done");
    } else {
        GAPID_INFO("glTexParameterIuiv at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterIuiv, s->GlesSpy::imports().glTexParameterIuiv);
        s->GlesSpy::imports().glTexParameterIuiv(target, pname, params);
        GAPID_DEBUG("glTexParameterIuiv() -- done");
    }
}
EXPORT void STDCALL glTexParameterf(uint32_t target, uint32_t parameter, GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterf(%u, %u, %f)", target, parameter, value);
    if (s->enter("glTexParameterf")) {
        s->glTexParameterf(target, parameter, value);
        s->exit();
        GAPID_DEBUG("glTexParameterf() -- done");
    } else {
        GAPID_INFO("glTexParameterf at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterf, s->GlesSpy::imports().glTexParameterf);
        s->GlesSpy::imports().glTexParameterf(target, parameter, value);
        GAPID_DEBUG("glTexParameterf() -- done");
    }
}
EXPORT void STDCALL glTexParameterfv(uint32_t target, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterfv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterfv")) {
        s->glTexParameterfv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterfv() -- done");
    } else {
        GAPID_INFO("glTexParameterfv at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterfv, s->GlesSpy::imports().glTexParameterfv);
        s->GlesSpy::imports().glTexParameterfv(target, pname, params);
        GAPID_DEBUG("glTexParameterfv() -- done");
    }
}
EXPORT void STDCALL glTexParameteri(uint32_t target, uint32_t parameter, GLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameteri(%u, %u, %" PRId32 ")", target, parameter, value);
    if (s->enter("glTexParameteri")) {
        s->glTexParameteri(target, parameter, value);
        s->exit();
        GAPID_DEBUG("glTexParameteri() -- done");
    } else {
        GAPID_INFO("glTexParameteri at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameteri, s->GlesSpy::imports().glTexParameteri);
        s->GlesSpy::imports().glTexParameteri(target, parameter, value);
        GAPID_DEBUG("glTexParameteri() -- done");
    }
}
EXPORT void STDCALL glTexParameteriv(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameteriv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameteriv")) {
        s->glTexParameteriv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameteriv() -- done");
    } else {
        GAPID_INFO("glTexParameteriv at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameteriv, s->GlesSpy::imports().glTexParameteriv);
        s->GlesSpy::imports().glTexParameteriv(target, pname, params);
        GAPID_DEBUG("glTexParameteriv() -- done");
    }
}
EXPORT void STDCALL glTexStorage2D(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, levels, internalformat, width, height);
    if (s->enter("glTexStorage2D")) {
        s->glTexStorage2D(target, levels, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glTexStorage2D() -- done");
    } else {
        GAPID_INFO("glTexStorage2D at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage2D, s->GlesSpy::imports().glTexStorage2D);
        s->GlesSpy::imports().glTexStorage2D(target, levels, internalformat, width, height);
        GAPID_DEBUG("glTexStorage2D() -- done");
    }
}
EXPORT void STDCALL glTexStorage2DMultisample(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage2DMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, samples, internalformat, width, height, fixedsamplelocations);
    if (s->enter("glTexStorage2DMultisample")) {
        s->glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
        s->exit();
        GAPID_DEBUG("glTexStorage2DMultisample() -- done");
    } else {
        GAPID_INFO("glTexStorage2DMultisample at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage2DMultisample, s->GlesSpy::imports().glTexStorage2DMultisample);
        s->GlesSpy::imports().glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
        GAPID_DEBUG("glTexStorage2DMultisample() -- done");
    }
}
EXPORT void STDCALL glTexStorage3D(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage3D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, levels, internalformat, width, height, depth);
    if (s->enter("glTexStorage3D")) {
        s->glTexStorage3D(target, levels, internalformat, width, height, depth);
        s->exit();
        GAPID_DEBUG("glTexStorage3D() -- done");
    } else {
        GAPID_INFO("glTexStorage3D at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage3D, s->GlesSpy::imports().glTexStorage3D);
        s->GlesSpy::imports().glTexStorage3D(target, levels, internalformat, width, height, depth);
        GAPID_DEBUG("glTexStorage3D() -- done");
    }
}
EXPORT void STDCALL glTexStorage3DMultisample(uint32_t target, GLsizei samples, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage3DMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, samples, internalformat, width, height, depth, fixedsamplelocations);
    if (s->enter("glTexStorage3DMultisample")) {
        s->glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
        s->exit();
        GAPID_DEBUG("glTexStorage3DMultisample() -- done");
    } else {
        GAPID_INFO("glTexStorage3DMultisample at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage3DMultisample, s->GlesSpy::imports().glTexStorage3DMultisample);
        s->GlesSpy::imports().glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
        GAPID_DEBUG("glTexStorage3DMultisample() -- done");
    }
}
EXPORT void STDCALL glTexSubImage2D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, uint32_t format, uint32_t type, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, width, height, format, type, data);
    if (s->enter("glTexSubImage2D")) {
        s->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
        s->exit();
        GAPID_DEBUG("glTexSubImage2D() -- done");
    } else {
        GAPID_INFO("glTexSubImage2D at %p: GAPII re-entered. Just invoking imported function at %p", glTexSubImage2D, s->GlesSpy::imports().glTexSubImage2D);
        s->GlesSpy::imports().glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
        GAPID_DEBUG("glTexSubImage2D() -- done");
    }
}
EXPORT void STDCALL glTexSubImage3D(uint32_t target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, TexturePointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
    if (s->enter("glTexSubImage3D")) {
        s->glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
        s->exit();
        GAPID_DEBUG("glTexSubImage3D() -- done");
    } else {
        GAPID_INFO("glTexSubImage3D at %p: GAPII re-entered. Just invoking imported function at %p", glTexSubImage3D, s->GlesSpy::imports().glTexSubImage3D);
        s->GlesSpy::imports().glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
        GAPID_DEBUG("glTexSubImage3D() -- done");
    }
}
EXPORT void STDCALL glBeginTransformFeedback(uint32_t primitiveMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginTransformFeedback(%u)", primitiveMode);
    if (s->enter("glBeginTransformFeedback")) {
        s->glBeginTransformFeedback(primitiveMode);
        s->exit();
        GAPID_DEBUG("glBeginTransformFeedback() -- done");
    } else {
        GAPID_INFO("glBeginTransformFeedback at %p: GAPII re-entered. Just invoking imported function at %p", glBeginTransformFeedback, s->GlesSpy::imports().glBeginTransformFeedback);
        s->GlesSpy::imports().glBeginTransformFeedback(primitiveMode);
        GAPID_DEBUG("glBeginTransformFeedback() -- done");
    }
}
EXPORT void STDCALL glBindTransformFeedback(uint32_t target, TransformFeedbackId id) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindTransformFeedback(%u, %" PRIu32 ")", target, id);
    if (s->enter("glBindTransformFeedback")) {
        s->glBindTransformFeedback(target, id);
        s->exit();
        GAPID_DEBUG("glBindTransformFeedback() -- done");
    } else {
        GAPID_INFO("glBindTransformFeedback at %p: GAPII re-entered. Just invoking imported function at %p", glBindTransformFeedback, s->GlesSpy::imports().glBindTransformFeedback);
        s->GlesSpy::imports().glBindTransformFeedback(target, id);
        GAPID_DEBUG("glBindTransformFeedback() -- done");
    }
}
EXPORT void STDCALL glDeleteTransformFeedbacks(GLsizei n, TransformFeedbackId* ids) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteTransformFeedbacks(%" PRId32 ", %p)", n, ids);
    if (s->enter("glDeleteTransformFeedbacks")) {
        s->glDeleteTransformFeedbacks(n, ids);
        s->exit();
        GAPID_DEBUG("glDeleteTransformFeedbacks() -- done");
    } else {
        GAPID_INFO("glDeleteTransformFeedbacks at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteTransformFeedbacks, s->GlesSpy::imports().glDeleteTransformFeedbacks);
        s->GlesSpy::imports().glDeleteTransformFeedbacks(n, ids);
        GAPID_DEBUG("glDeleteTransformFeedbacks() -- done");
    }
}
EXPORT void STDCALL glEndTransformFeedback() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndTransformFeedback()");
    if (s->enter("glEndTransformFeedback")) {
        s->glEndTransformFeedback();
        s->exit();
        GAPID_DEBUG("glEndTransformFeedback() -- done");
    } else {
        GAPID_INFO("glEndTransformFeedback at %p: GAPII re-entered. Just invoking imported function at %p", glEndTransformFeedback, s->GlesSpy::imports().glEndTransformFeedback);
        s->GlesSpy::imports().glEndTransformFeedback();
        GAPID_DEBUG("glEndTransformFeedback() -- done");
    }
}
EXPORT void STDCALL glGenTransformFeedbacks(GLsizei n, TransformFeedbackId* ids) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenTransformFeedbacks(%" PRId32 ", %p)", n, ids);
    if (s->enter("glGenTransformFeedbacks")) {
        s->glGenTransformFeedbacks(n, ids);
        s->exit();
        GAPID_DEBUG("glGenTransformFeedbacks() -- done");
    } else {
        GAPID_INFO("glGenTransformFeedbacks at %p: GAPII re-entered. Just invoking imported function at %p", glGenTransformFeedbacks, s->GlesSpy::imports().glGenTransformFeedbacks);
        s->GlesSpy::imports().glGenTransformFeedbacks(n, ids);
        GAPID_DEBUG("glGenTransformFeedbacks() -- done");
    }
}
EXPORT void STDCALL glGetTransformFeedbackVarying(ProgramId program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, uint32_t* type, GLchar* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTransformFeedbackVarying(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)", program, index, bufSize, length, size, type, name);
    if (s->enter("glGetTransformFeedbackVarying")) {
        s->glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
        s->exit();
        GAPID_DEBUG("glGetTransformFeedbackVarying() -- done");
    } else {
        GAPID_INFO("glGetTransformFeedbackVarying at %p: GAPII re-entered. Just invoking imported function at %p", glGetTransformFeedbackVarying, s->GlesSpy::imports().glGetTransformFeedbackVarying);
        s->GlesSpy::imports().glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
        GAPID_DEBUG("glGetTransformFeedbackVarying() -- done");
    }
}
EXPORT GLboolean STDCALL glIsTransformFeedback(TransformFeedbackId id) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsTransformFeedback(%" PRIu32 ")", id);
    if (s->enter("glIsTransformFeedback")) {
        auto _result_ = s->glIsTransformFeedback(id);
        s->exit();
        GAPID_DEBUG("glIsTransformFeedback() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsTransformFeedback at %p: GAPII re-entered. Just invoking imported function at %p", glIsTransformFeedback, s->GlesSpy::imports().glIsTransformFeedback);
        auto _result_ = s->GlesSpy::imports().glIsTransformFeedback(id);
        GAPID_DEBUG("glIsTransformFeedback() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glPauseTransformFeedback() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPauseTransformFeedback()");
    if (s->enter("glPauseTransformFeedback")) {
        s->glPauseTransformFeedback();
        s->exit();
        GAPID_DEBUG("glPauseTransformFeedback() -- done");
    } else {
        GAPID_INFO("glPauseTransformFeedback at %p: GAPII re-entered. Just invoking imported function at %p", glPauseTransformFeedback, s->GlesSpy::imports().glPauseTransformFeedback);
        s->GlesSpy::imports().glPauseTransformFeedback();
        GAPID_DEBUG("glPauseTransformFeedback() -- done");
    }
}
EXPORT void STDCALL glResumeTransformFeedback() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glResumeTransformFeedback()");
    if (s->enter("glResumeTransformFeedback")) {
        s->glResumeTransformFeedback();
        s->exit();
        GAPID_DEBUG("glResumeTransformFeedback() -- done");
    } else {
        GAPID_INFO("glResumeTransformFeedback at %p: GAPII re-entered. Just invoking imported function at %p", glResumeTransformFeedback, s->GlesSpy::imports().glResumeTransformFeedback);
        s->GlesSpy::imports().glResumeTransformFeedback();
        GAPID_DEBUG("glResumeTransformFeedback() -- done");
    }
}
EXPORT void STDCALL glTransformFeedbackVaryings(ProgramId program, GLsizei count, GLchar** varyings, uint32_t bufferMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTransformFeedbackVaryings(%" PRIu32 ", %" PRId32 ", %p, %u)", program, count, varyings, bufferMode);
    if (s->enter("glTransformFeedbackVaryings")) {
        s->glTransformFeedbackVaryings(program, count, varyings, bufferMode);
        s->exit();
        GAPID_DEBUG("glTransformFeedbackVaryings() -- done");
    } else {
        GAPID_INFO("glTransformFeedbackVaryings at %p: GAPII re-entered. Just invoking imported function at %p", glTransformFeedbackVaryings, s->GlesSpy::imports().glTransformFeedbackVaryings);
        s->GlesSpy::imports().glTransformFeedbackVaryings(program, count, varyings, bufferMode);
        GAPID_DEBUG("glTransformFeedbackVaryings() -- done");
    }
}
EXPORT void STDCALL glBindVertexArray(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindVertexArray(%" PRIu32 ")", array);
    if (s->enter("glBindVertexArray")) {
        s->glBindVertexArray(array);
        s->exit();
        GAPID_DEBUG("glBindVertexArray() -- done");
    } else {
        GAPID_INFO("glBindVertexArray at %p: GAPII re-entered. Just invoking imported function at %p", glBindVertexArray, s->GlesSpy::imports().glBindVertexArray);
        s->GlesSpy::imports().glBindVertexArray(array);
        GAPID_DEBUG("glBindVertexArray() -- done");
    }
}
EXPORT void STDCALL glBindVertexBuffer(VertexBufferBindingIndex binding_index, BufferId buffer, GLintptr offset, GLsizei stride) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindVertexBuffer(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")", binding_index, buffer, offset, stride);
    if (s->enter("glBindVertexBuffer")) {
        s->glBindVertexBuffer(binding_index, buffer, offset, stride);
        s->exit();
        GAPID_DEBUG("glBindVertexBuffer() -- done");
    } else {
        GAPID_INFO("glBindVertexBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glBindVertexBuffer, s->GlesSpy::imports().glBindVertexBuffer);
        s->GlesSpy::imports().glBindVertexBuffer(binding_index, buffer, offset, stride);
        GAPID_DEBUG("glBindVertexBuffer() -- done");
    }
}
EXPORT void STDCALL glDeleteVertexArrays(GLsizei count, VertexArrayId* arrays) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteVertexArrays(%" PRId32 ", %p)", count, arrays);
    if (s->enter("glDeleteVertexArrays")) {
        s->glDeleteVertexArrays(count, arrays);
        s->exit();
        GAPID_DEBUG("glDeleteVertexArrays() -- done");
    } else {
        GAPID_INFO("glDeleteVertexArrays at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteVertexArrays, s->GlesSpy::imports().glDeleteVertexArrays);
        s->GlesSpy::imports().glDeleteVertexArrays(count, arrays);
        GAPID_DEBUG("glDeleteVertexArrays() -- done");
    }
}
EXPORT void STDCALL glDisableVertexAttribArray(AttributeLocation location) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableVertexAttribArray(%" PRIu32 ")", location);
    if (s->enter("glDisableVertexAttribArray")) {
        s->glDisableVertexAttribArray(location);
        s->exit();
        GAPID_DEBUG("glDisableVertexAttribArray() -- done");
    } else {
        GAPID_INFO("glDisableVertexAttribArray at %p: GAPII re-entered. Just invoking imported function at %p", glDisableVertexAttribArray, s->GlesSpy::imports().glDisableVertexAttribArray);
        s->GlesSpy::imports().glDisableVertexAttribArray(location);
        GAPID_DEBUG("glDisableVertexAttribArray() -- done");
    }
}
EXPORT void STDCALL glEnableVertexAttribArray(AttributeLocation location) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableVertexAttribArray(%" PRIu32 ")", location);
    if (s->enter("glEnableVertexAttribArray")) {
        s->glEnableVertexAttribArray(location);
        s->exit();
        GAPID_DEBUG("glEnableVertexAttribArray() -- done");
    } else {
        GAPID_INFO("glEnableVertexAttribArray at %p: GAPII re-entered. Just invoking imported function at %p", glEnableVertexAttribArray, s->GlesSpy::imports().glEnableVertexAttribArray);
        s->GlesSpy::imports().glEnableVertexAttribArray(location);
        GAPID_DEBUG("glEnableVertexAttribArray() -- done");
    }
}
EXPORT void STDCALL glGenVertexArrays(GLsizei count, VertexArrayId* arrays) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenVertexArrays(%" PRId32 ", %p)", count, arrays);
    if (s->enter("glGenVertexArrays")) {
        s->glGenVertexArrays(count, arrays);
        s->exit();
        GAPID_DEBUG("glGenVertexArrays() -- done");
    } else {
        GAPID_INFO("glGenVertexArrays at %p: GAPII re-entered. Just invoking imported function at %p", glGenVertexArrays, s->GlesSpy::imports().glGenVertexArrays);
        s->GlesSpy::imports().glGenVertexArrays(count, arrays);
        GAPID_DEBUG("glGenVertexArrays() -- done");
    }
}
EXPORT void STDCALL glGetVertexAttribIiv(AttributeLocation index, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetVertexAttribIiv(%" PRIu32 ", %u, %p)", index, pname, params);
    if (s->enter("glGetVertexAttribIiv")) {
        s->glGetVertexAttribIiv(index, pname, params);
        s->exit();
        GAPID_DEBUG("glGetVertexAttribIiv() -- done");
    } else {
        GAPID_INFO("glGetVertexAttribIiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetVertexAttribIiv, s->GlesSpy::imports().glGetVertexAttribIiv);
        s->GlesSpy::imports().glGetVertexAttribIiv(index, pname, params);
        GAPID_DEBUG("glGetVertexAttribIiv() -- done");
    }
}
EXPORT void STDCALL glGetVertexAttribIuiv(AttributeLocation index, uint32_t pname, GLuint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetVertexAttribIuiv(%" PRIu32 ", %u, %p)", index, pname, params);
    if (s->enter("glGetVertexAttribIuiv")) {
        s->glGetVertexAttribIuiv(index, pname, params);
        s->exit();
        GAPID_DEBUG("glGetVertexAttribIuiv() -- done");
    } else {
        GAPID_INFO("glGetVertexAttribIuiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetVertexAttribIuiv, s->GlesSpy::imports().glGetVertexAttribIuiv);
        s->GlesSpy::imports().glGetVertexAttribIuiv(index, pname, params);
        GAPID_DEBUG("glGetVertexAttribIuiv() -- done");
    }
}
EXPORT void STDCALL glGetVertexAttribPointerv(AttributeLocation index, uint32_t pname, void** pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetVertexAttribPointerv(%" PRIu32 ", %u, %p)", index, pname, pointer);
    if (s->enter("glGetVertexAttribPointerv")) {
        s->glGetVertexAttribPointerv(index, pname, pointer);
        s->exit();
        GAPID_DEBUG("glGetVertexAttribPointerv() -- done");
    } else {
        GAPID_INFO("glGetVertexAttribPointerv at %p: GAPII re-entered. Just invoking imported function at %p", glGetVertexAttribPointerv, s->GlesSpy::imports().glGetVertexAttribPointerv);
        s->GlesSpy::imports().glGetVertexAttribPointerv(index, pname, pointer);
        GAPID_DEBUG("glGetVertexAttribPointerv() -- done");
    }
}
EXPORT void STDCALL glGetVertexAttribfv(AttributeLocation index, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetVertexAttribfv(%" PRIu32 ", %u, %p)", index, pname, params);
    if (s->enter("glGetVertexAttribfv")) {
        s->glGetVertexAttribfv(index, pname, params);
        s->exit();
        GAPID_DEBUG("glGetVertexAttribfv() -- done");
    } else {
        GAPID_INFO("glGetVertexAttribfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetVertexAttribfv, s->GlesSpy::imports().glGetVertexAttribfv);
        s->GlesSpy::imports().glGetVertexAttribfv(index, pname, params);
        GAPID_DEBUG("glGetVertexAttribfv() -- done");
    }
}
EXPORT void STDCALL glGetVertexAttribiv(AttributeLocation index, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetVertexAttribiv(%" PRIu32 ", %u, %p)", index, pname, params);
    if (s->enter("glGetVertexAttribiv")) {
        s->glGetVertexAttribiv(index, pname, params);
        s->exit();
        GAPID_DEBUG("glGetVertexAttribiv() -- done");
    } else {
        GAPID_INFO("glGetVertexAttribiv at %p: GAPII re-entered. Just invoking imported function at %p", glGetVertexAttribiv, s->GlesSpy::imports().glGetVertexAttribiv);
        s->GlesSpy::imports().glGetVertexAttribiv(index, pname, params);
        GAPID_DEBUG("glGetVertexAttribiv() -- done");
    }
}
EXPORT GLboolean STDCALL glIsVertexArray(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsVertexArray(%" PRIu32 ")", array);
    if (s->enter("glIsVertexArray")) {
        auto _result_ = s->glIsVertexArray(array);
        s->exit();
        GAPID_DEBUG("glIsVertexArray() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsVertexArray at %p: GAPII re-entered. Just invoking imported function at %p", glIsVertexArray, s->GlesSpy::imports().glIsVertexArray);
        auto _result_ = s->GlesSpy::imports().glIsVertexArray(array);
        GAPID_DEBUG("glIsVertexArray() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glVertexAttrib1f(AttributeLocation location, GLfloat value0) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib1f(%" PRIu32 ", %f)", location, value0);
    if (s->enter("glVertexAttrib1f")) {
        s->glVertexAttrib1f(location, value0);
        s->exit();
        GAPID_DEBUG("glVertexAttrib1f() -- done");
    } else {
        GAPID_INFO("glVertexAttrib1f at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib1f, s->GlesSpy::imports().glVertexAttrib1f);
        s->GlesSpy::imports().glVertexAttrib1f(location, value0);
        GAPID_DEBUG("glVertexAttrib1f() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib1fv(AttributeLocation location, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib1fv(%" PRIu32 ", %p)", location, value);
    if (s->enter("glVertexAttrib1fv")) {
        s->glVertexAttrib1fv(location, value);
        s->exit();
        GAPID_DEBUG("glVertexAttrib1fv() -- done");
    } else {
        GAPID_INFO("glVertexAttrib1fv at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib1fv, s->GlesSpy::imports().glVertexAttrib1fv);
        s->GlesSpy::imports().glVertexAttrib1fv(location, value);
        GAPID_DEBUG("glVertexAttrib1fv() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib2f(AttributeLocation location, GLfloat value0, GLfloat value1) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib2f(%" PRIu32 ", %f, %f)", location, value0, value1);
    if (s->enter("glVertexAttrib2f")) {
        s->glVertexAttrib2f(location, value0, value1);
        s->exit();
        GAPID_DEBUG("glVertexAttrib2f() -- done");
    } else {
        GAPID_INFO("glVertexAttrib2f at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib2f, s->GlesSpy::imports().glVertexAttrib2f);
        s->GlesSpy::imports().glVertexAttrib2f(location, value0, value1);
        GAPID_DEBUG("glVertexAttrib2f() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib2fv(AttributeLocation location, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib2fv(%" PRIu32 ", %p)", location, value);
    if (s->enter("glVertexAttrib2fv")) {
        s->glVertexAttrib2fv(location, value);
        s->exit();
        GAPID_DEBUG("glVertexAttrib2fv() -- done");
    } else {
        GAPID_INFO("glVertexAttrib2fv at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib2fv, s->GlesSpy::imports().glVertexAttrib2fv);
        s->GlesSpy::imports().glVertexAttrib2fv(location, value);
        GAPID_DEBUG("glVertexAttrib2fv() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib3f(AttributeLocation location, GLfloat value0, GLfloat value1, GLfloat value2) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib3f(%" PRIu32 ", %f, %f, %f)", location, value0, value1, value2);
    if (s->enter("glVertexAttrib3f")) {
        s->glVertexAttrib3f(location, value0, value1, value2);
        s->exit();
        GAPID_DEBUG("glVertexAttrib3f() -- done");
    } else {
        GAPID_INFO("glVertexAttrib3f at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib3f, s->GlesSpy::imports().glVertexAttrib3f);
        s->GlesSpy::imports().glVertexAttrib3f(location, value0, value1, value2);
        GAPID_DEBUG("glVertexAttrib3f() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib3fv(AttributeLocation location, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib3fv(%" PRIu32 ", %p)", location, value);
    if (s->enter("glVertexAttrib3fv")) {
        s->glVertexAttrib3fv(location, value);
        s->exit();
        GAPID_DEBUG("glVertexAttrib3fv() -- done");
    } else {
        GAPID_INFO("glVertexAttrib3fv at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib3fv, s->GlesSpy::imports().glVertexAttrib3fv);
        s->GlesSpy::imports().glVertexAttrib3fv(location, value);
        GAPID_DEBUG("glVertexAttrib3fv() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib4f(AttributeLocation location, GLfloat value0, GLfloat value1, GLfloat value2, GLfloat value3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib4f(%" PRIu32 ", %f, %f, %f, %f)", location, value0, value1, value2, value3);
    if (s->enter("glVertexAttrib4f")) {
        s->glVertexAttrib4f(location, value0, value1, value2, value3);
        s->exit();
        GAPID_DEBUG("glVertexAttrib4f() -- done");
    } else {
        GAPID_INFO("glVertexAttrib4f at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib4f, s->GlesSpy::imports().glVertexAttrib4f);
        s->GlesSpy::imports().glVertexAttrib4f(location, value0, value1, value2, value3);
        GAPID_DEBUG("glVertexAttrib4f() -- done");
    }
}
EXPORT void STDCALL glVertexAttrib4fv(AttributeLocation location, GLfloat* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttrib4fv(%" PRIu32 ", %p)", location, value);
    if (s->enter("glVertexAttrib4fv")) {
        s->glVertexAttrib4fv(location, value);
        s->exit();
        GAPID_DEBUG("glVertexAttrib4fv() -- done");
    } else {
        GAPID_INFO("glVertexAttrib4fv at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttrib4fv, s->GlesSpy::imports().glVertexAttrib4fv);
        s->GlesSpy::imports().glVertexAttrib4fv(location, value);
        GAPID_DEBUG("glVertexAttrib4fv() -- done");
    }
}
EXPORT void STDCALL glVertexAttribBinding(AttributeLocation index, VertexBufferBindingIndex binding_index) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribBinding(%" PRIu32 ", %" PRIu32 ")", index, binding_index);
    if (s->enter("glVertexAttribBinding")) {
        s->glVertexAttribBinding(index, binding_index);
        s->exit();
        GAPID_DEBUG("glVertexAttribBinding() -- done");
    } else {
        GAPID_INFO("glVertexAttribBinding at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribBinding, s->GlesSpy::imports().glVertexAttribBinding);
        s->GlesSpy::imports().glVertexAttribBinding(index, binding_index);
        GAPID_DEBUG("glVertexAttribBinding() -- done");
    }
}
EXPORT void STDCALL glVertexAttribDivisor(AttributeLocation index, GLuint divisor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribDivisor(%" PRIu32 ", %" PRIu32 ")", index, divisor);
    if (s->enter("glVertexAttribDivisor")) {
        s->glVertexAttribDivisor(index, divisor);
        s->exit();
        GAPID_DEBUG("glVertexAttribDivisor() -- done");
    } else {
        GAPID_INFO("glVertexAttribDivisor at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribDivisor, s->GlesSpy::imports().glVertexAttribDivisor);
        s->GlesSpy::imports().glVertexAttribDivisor(index, divisor);
        GAPID_DEBUG("glVertexAttribDivisor() -- done");
    }
}
EXPORT void STDCALL glVertexAttribFormat(AttributeLocation index, GLint size, uint32_t type, GLboolean normalized, GLuint relativeoffset) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribFormat(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRIu32 ")", index, size, type, normalized, relativeoffset);
    if (s->enter("glVertexAttribFormat")) {
        s->glVertexAttribFormat(index, size, type, normalized, relativeoffset);
        s->exit();
        GAPID_DEBUG("glVertexAttribFormat() -- done");
    } else {
        GAPID_INFO("glVertexAttribFormat at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribFormat, s->GlesSpy::imports().glVertexAttribFormat);
        s->GlesSpy::imports().glVertexAttribFormat(index, size, type, normalized, relativeoffset);
        GAPID_DEBUG("glVertexAttribFormat() -- done");
    }
}
EXPORT void STDCALL glVertexAttribI4i(AttributeLocation index, GLint x, GLint y, GLint z, GLint w) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribI4i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", index, x, y, z, w);
    if (s->enter("glVertexAttribI4i")) {
        s->glVertexAttribI4i(index, x, y, z, w);
        s->exit();
        GAPID_DEBUG("glVertexAttribI4i() -- done");
    } else {
        GAPID_INFO("glVertexAttribI4i at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribI4i, s->GlesSpy::imports().glVertexAttribI4i);
        s->GlesSpy::imports().glVertexAttribI4i(index, x, y, z, w);
        GAPID_DEBUG("glVertexAttribI4i() -- done");
    }
}
EXPORT void STDCALL glVertexAttribI4iv(AttributeLocation index, GLint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribI4iv(%" PRIu32 ", %p)", index, values);
    if (s->enter("glVertexAttribI4iv")) {
        s->glVertexAttribI4iv(index, values);
        s->exit();
        GAPID_DEBUG("glVertexAttribI4iv() -- done");
    } else {
        GAPID_INFO("glVertexAttribI4iv at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribI4iv, s->GlesSpy::imports().glVertexAttribI4iv);
        s->GlesSpy::imports().glVertexAttribI4iv(index, values);
        GAPID_DEBUG("glVertexAttribI4iv() -- done");
    }
}
EXPORT void STDCALL glVertexAttribI4ui(AttributeLocation index, GLuint x, GLuint y, GLuint z, GLuint w) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribI4ui(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", index, x, y, z, w);
    if (s->enter("glVertexAttribI4ui")) {
        s->glVertexAttribI4ui(index, x, y, z, w);
        s->exit();
        GAPID_DEBUG("glVertexAttribI4ui() -- done");
    } else {
        GAPID_INFO("glVertexAttribI4ui at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribI4ui, s->GlesSpy::imports().glVertexAttribI4ui);
        s->GlesSpy::imports().glVertexAttribI4ui(index, x, y, z, w);
        GAPID_DEBUG("glVertexAttribI4ui() -- done");
    }
}
EXPORT void STDCALL glVertexAttribI4uiv(AttributeLocation index, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribI4uiv(%" PRIu32 ", %p)", index, values);
    if (s->enter("glVertexAttribI4uiv")) {
        s->glVertexAttribI4uiv(index, values);
        s->exit();
        GAPID_DEBUG("glVertexAttribI4uiv() -- done");
    } else {
        GAPID_INFO("glVertexAttribI4uiv at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribI4uiv, s->GlesSpy::imports().glVertexAttribI4uiv);
        s->GlesSpy::imports().glVertexAttribI4uiv(index, values);
        GAPID_DEBUG("glVertexAttribI4uiv() -- done");
    }
}
EXPORT void STDCALL glVertexAttribIFormat(AttributeLocation index, GLint size, uint32_t type, GLuint relativeoffset) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribIFormat(%" PRIu32 ", %" PRId32 ", %u, %" PRIu32 ")", index, size, type, relativeoffset);
    if (s->enter("glVertexAttribIFormat")) {
        s->glVertexAttribIFormat(index, size, type, relativeoffset);
        s->exit();
        GAPID_DEBUG("glVertexAttribIFormat() -- done");
    } else {
        GAPID_INFO("glVertexAttribIFormat at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribIFormat, s->GlesSpy::imports().glVertexAttribIFormat);
        s->GlesSpy::imports().glVertexAttribIFormat(index, size, type, relativeoffset);
        GAPID_DEBUG("glVertexAttribIFormat() -- done");
    }
}
EXPORT void STDCALL glVertexAttribIPointer(AttributeLocation location, GLint size, uint32_t type, GLsizei stride, VertexPointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribIPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRId32 ", %p)", location, size, type, stride, data);
    if (s->enter("glVertexAttribIPointer")) {
        s->glVertexAttribIPointer(location, size, type, stride, data);
        s->exit();
        GAPID_DEBUG("glVertexAttribIPointer() -- done");
    } else {
        GAPID_INFO("glVertexAttribIPointer at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribIPointer, s->GlesSpy::imports().glVertexAttribIPointer);
        s->GlesSpy::imports().glVertexAttribIPointer(location, size, type, stride, data);
        GAPID_DEBUG("glVertexAttribIPointer() -- done");
    }
}
EXPORT void STDCALL glVertexAttribPointer(AttributeLocation location, GLint size, uint32_t type, GLboolean normalized, GLsizei stride, VertexPointer data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRId32 ", %p)", location, size, type, normalized, stride, data);
    if (s->enter("glVertexAttribPointer")) {
        s->glVertexAttribPointer(location, size, type, normalized, stride, data);
        s->exit();
        GAPID_DEBUG("glVertexAttribPointer() -- done");
    } else {
        GAPID_INFO("glVertexAttribPointer at %p: GAPII re-entered. Just invoking imported function at %p", glVertexAttribPointer, s->GlesSpy::imports().glVertexAttribPointer);
        s->GlesSpy::imports().glVertexAttribPointer(location, size, type, normalized, stride, data);
        GAPID_DEBUG("glVertexAttribPointer() -- done");
    }
}
EXPORT void STDCALL glVertexBindingDivisor(VertexBufferBindingIndex binding_index, GLuint divisor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexBindingDivisor(%" PRIu32 ", %" PRIu32 ")", binding_index, divisor);
    if (s->enter("glVertexBindingDivisor")) {
        s->glVertexBindingDivisor(binding_index, divisor);
        s->exit();
        GAPID_DEBUG("glVertexBindingDivisor() -- done");
    } else {
        GAPID_INFO("glVertexBindingDivisor at %p: GAPII re-entered. Just invoking imported function at %p", glVertexBindingDivisor, s->GlesSpy::imports().glVertexBindingDivisor);
        s->GlesSpy::imports().glVertexBindingDivisor(binding_index, divisor);
        GAPID_DEBUG("glVertexBindingDivisor() -- done");
    }
}
EXPORT EGLBoolean STDCALL eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglInitialize(%p, %p, %p)", dpy, major, minor);
    if (s->enter("eglInitialize")) {
        auto _result_ = s->eglInitialize(dpy, major, minor);
        s->exit();
        GAPID_DEBUG("eglInitialize() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglInitialize at %p: GAPII re-entered. Just invoking imported function at %p", eglInitialize, s->GlesSpy::imports().eglInitialize);
        auto _result_ = s->GlesSpy::imports().eglInitialize(dpy, major, minor);
        GAPID_DEBUG("eglInitialize() -- done");
        return _result_;
    }
}
EXPORT EGLContext STDCALL eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreateContext(%p, %p, %p, %p)", display, config, share_context, attrib_list);
    if (s->enter("eglCreateContext")) {
        auto _result_ = s->eglCreateContext(display, config, share_context, attrib_list);
        s->exit();
        GAPID_DEBUG("eglCreateContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglCreateContext at %p: GAPII re-entered. Just invoking imported function at %p", eglCreateContext, s->GlesSpy::imports().eglCreateContext);
        auto _result_ = s->GlesSpy::imports().eglCreateContext(display, config, share_context, attrib_list);
        GAPID_DEBUG("eglCreateContext() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglMakeCurrent(%p, %p, %p, %p)", display, draw, read, context);
    if (s->enter("eglMakeCurrent")) {
        auto _result_ = s->eglMakeCurrent(display, draw, read, context);
        s->exit();
        GAPID_DEBUG("eglMakeCurrent() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglMakeCurrent at %p: GAPII re-entered. Just invoking imported function at %p", eglMakeCurrent, s->GlesSpy::imports().eglMakeCurrent);
        auto _result_ = s->GlesSpy::imports().eglMakeCurrent(display, draw, read, context);
        GAPID_DEBUG("eglMakeCurrent() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglSwapBuffers(EGLDisplay display, void* surface) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglSwapBuffers(%p, %p)", display, surface);
    if (s->enter("eglSwapBuffers")) {
        auto _result_ = s->eglSwapBuffers(display, surface);
        s->exit();
        GAPID_DEBUG("eglSwapBuffers() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglSwapBuffers at %p: GAPII re-entered. Just invoking imported function at %p", eglSwapBuffers, s->GlesSpy::imports().eglSwapBuffers);
        auto _result_ = s->GlesSpy::imports().eglSwapBuffers(display, surface);
        GAPID_DEBUG("eglSwapBuffers() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects, EGLint n_rects) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglSwapBuffersWithDamageKHR(%p, %p, %p, %d)", dpy, surface, rects, n_rects);
    if (s->enter("eglSwapBuffersWithDamageKHR")) {
        auto _result_ = s->eglSwapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
        s->exit();
        GAPID_DEBUG("eglSwapBuffersWithDamageKHR() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglSwapBuffersWithDamageKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglSwapBuffersWithDamageKHR, s->GlesSpy::imports().eglSwapBuffersWithDamageKHR);
        auto _result_ = s->GlesSpy::imports().eglSwapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
        GAPID_DEBUG("eglSwapBuffersWithDamageKHR() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglQuerySurface(%p, %p, %d, %p)", display, surface, attribute, value);
    if (s->enter("eglQuerySurface")) {
        auto _result_ = s->eglQuerySurface(display, surface, attribute, value);
        s->exit();
        GAPID_DEBUG("eglQuerySurface() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglQuerySurface at %p: GAPII re-entered. Just invoking imported function at %p", eglQuerySurface, s->GlesSpy::imports().eglQuerySurface);
        auto _result_ = s->GlesSpy::imports().eglQuerySurface(display, surface, attribute, value);
        GAPID_DEBUG("eglQuerySurface() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglQueryContext(EGLDisplay display, EGLContext context, EGLint attribute, EGLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglQueryContext(%p, %p, %d, %p)", display, context, attribute, value);
    if (s->enter("eglQueryContext")) {
        auto _result_ = s->eglQueryContext(display, context, attribute, value);
        s->exit();
        GAPID_DEBUG("eglQueryContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglQueryContext at %p: GAPII re-entered. Just invoking imported function at %p", eglQueryContext, s->GlesSpy::imports().eglQueryContext);
        auto _result_ = s->GlesSpy::imports().eglQueryContext(display, context, attribute, value);
        GAPID_DEBUG("eglQueryContext() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglChooseConfig(EGLDisplay display, EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglChooseConfig(%p, %p, %p, %d, %p)", display, attrib_list, configs, config_size, num_config);
    if (s->enter("eglChooseConfig")) {
        auto _result_ = s->eglChooseConfig(display, attrib_list, configs, config_size, num_config);
        s->exit();
        GAPID_DEBUG("eglChooseConfig() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglChooseConfig at %p: GAPII re-entered. Just invoking imported function at %p", eglChooseConfig, s->GlesSpy::imports().eglChooseConfig);
        auto _result_ = s->GlesSpy::imports().eglChooseConfig(display, attrib_list, configs, config_size, num_config);
        GAPID_DEBUG("eglChooseConfig() -- done");
        return _result_;
    }
}
EXPORT EGLBoolean STDCALL eglGetConfigAttrib(EGLDisplay display, EGLConfig config, EGLint attribute, EGLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetConfigAttrib(%p, %p, %d, %p)", display, config, attribute, value);
    if (s->enter("eglGetConfigAttrib")) {
        auto _result_ = s->eglGetConfigAttrib(display, config, attribute, value);
        s->exit();
        GAPID_DEBUG("eglGetConfigAttrib() -- done");
        return _result_;
    } else {
        GAPID_INFO("eglGetConfigAttrib at %p: GAPII re-entered. Just invoking imported function at %p", eglGetConfigAttrib, s->GlesSpy::imports().eglGetConfigAttrib);
        auto _result_ = s->GlesSpy::imports().eglGetConfigAttrib(display, config, attribute, value);
        GAPID_DEBUG("eglGetConfigAttrib() -- done");
        return _result_;
    }
}
EXPORT GLXContext STDCALL glXCreateContext(void* dpy, void* vis, GLXContext shareList, bool direct) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glXCreateContext(%p, %p, %p, %d)", dpy, vis, shareList, direct);
    if (s->enter("glXCreateContext")) {
        auto _result_ = s->glXCreateContext(dpy, vis, shareList, direct);
        s->exit();
        GAPID_DEBUG("glXCreateContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("glXCreateContext at %p: GAPII re-entered. Just invoking imported function at %p", glXCreateContext, s->GlesSpy::imports().glXCreateContext);
        auto _result_ = s->GlesSpy::imports().glXCreateContext(dpy, vis, shareList, direct);
        GAPID_DEBUG("glXCreateContext() -- done");
        return _result_;
    }
}
EXPORT GLXContext STDCALL glXCreateNewContext(void* display, void* fbconfig, uint32_t type, GLXContext shared, bool direct) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glXCreateNewContext(%p, %p, %" PRIu32 ", %p, %d)", display, fbconfig, type, shared, direct);
    if (s->enter("glXCreateNewContext")) {
        auto _result_ = s->glXCreateNewContext(display, fbconfig, type, shared, direct);
        s->exit();
        GAPID_DEBUG("glXCreateNewContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("glXCreateNewContext at %p: GAPII re-entered. Just invoking imported function at %p", glXCreateNewContext, s->GlesSpy::imports().glXCreateNewContext);
        auto _result_ = s->GlesSpy::imports().glXCreateNewContext(display, fbconfig, type, shared, direct);
        GAPID_DEBUG("glXCreateNewContext() -- done");
        return _result_;
    }
}
EXPORT Bool STDCALL glXMakeContextCurrent(void* display, GLXDrawable draw, GLXDrawable read, GLXContext ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glXMakeContextCurrent(%p, %p, %p, %p)", display, draw, read, ctx);
    if (s->enter("glXMakeContextCurrent")) {
        auto _result_ = s->glXMakeContextCurrent(display, draw, read, ctx);
        s->exit();
        GAPID_DEBUG("glXMakeContextCurrent() -- done");
        return _result_;
    } else {
        GAPID_INFO("glXMakeContextCurrent at %p: GAPII re-entered. Just invoking imported function at %p", glXMakeContextCurrent, s->GlesSpy::imports().glXMakeContextCurrent);
        auto _result_ = s->GlesSpy::imports().glXMakeContextCurrent(display, draw, read, ctx);
        GAPID_DEBUG("glXMakeContextCurrent() -- done");
        return _result_;
    }
}
EXPORT Bool STDCALL glXMakeCurrent(void* display, GLXDrawable drawable, GLXContext ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glXMakeCurrent(%p, %p, %p)", display, drawable, ctx);
    if (s->enter("glXMakeCurrent")) {
        auto _result_ = s->glXMakeCurrent(display, drawable, ctx);
        s->exit();
        GAPID_DEBUG("glXMakeCurrent() -- done");
        return _result_;
    } else {
        GAPID_INFO("glXMakeCurrent at %p: GAPII re-entered. Just invoking imported function at %p", glXMakeCurrent, s->GlesSpy::imports().glXMakeCurrent);
        auto _result_ = s->GlesSpy::imports().glXMakeCurrent(display, drawable, ctx);
        GAPID_DEBUG("glXMakeCurrent() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glXSwapBuffers(void* display, GLXDrawable drawable) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glXSwapBuffers(%p, %p)", display, drawable);
    if (s->enter("glXSwapBuffers")) {
        s->glXSwapBuffers(display, drawable);
        s->exit();
        GAPID_DEBUG("glXSwapBuffers() -- done");
    } else {
        GAPID_INFO("glXSwapBuffers at %p: GAPII re-entered. Just invoking imported function at %p", glXSwapBuffers, s->GlesSpy::imports().glXSwapBuffers);
        s->GlesSpy::imports().glXSwapBuffers(display, drawable);
        GAPID_DEBUG("glXSwapBuffers() -- done");
    }
}
EXPORT int STDCALL glXQueryDrawable(void* display, GLXDrawable draw, int attribute, int* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glXQueryDrawable(%p, %p, %d, %p)", display, draw, attribute, value);
    if (s->enter("glXQueryDrawable")) {
        auto _result_ = s->glXQueryDrawable(display, draw, attribute, value);
        s->exit();
        GAPID_DEBUG("glXQueryDrawable() -- done");
        return _result_;
    } else {
        GAPID_INFO("glXQueryDrawable at %p: GAPII re-entered. Just invoking imported function at %p", glXQueryDrawable, s->GlesSpy::imports().glXQueryDrawable);
        auto _result_ = s->GlesSpy::imports().glXQueryDrawable(display, draw, attribute, value);
        GAPID_DEBUG("glXQueryDrawable() -- done");
        return _result_;
    }
}
EXPORT HGLRC STDCALL wglCreateContext(HDC hdc) {
    Spy* s = Spy::get();
    GAPID_DEBUG("wglCreateContext(%p)", hdc);
    if (s->enter("wglCreateContext")) {
        auto _result_ = s->wglCreateContext(hdc);
        s->exit();
        GAPID_DEBUG("wglCreateContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("wglCreateContext at %p: GAPII re-entered. Just invoking imported function at %p", wglCreateContext, s->GlesSpy::imports().wglCreateContext);
        auto _result_ = s->GlesSpy::imports().wglCreateContext(hdc);
        GAPID_DEBUG("wglCreateContext() -- done");
        return _result_;
    }
}
EXPORT HGLRC STDCALL wglCreateContextAttribsARB(HDC hdc, HGLRC hShareContext, int* attribList) {
    Spy* s = Spy::get();
    GAPID_DEBUG("wglCreateContextAttribsARB(%p, %p, %p)", hdc, hShareContext, attribList);
    if (s->enter("wglCreateContextAttribsARB")) {
        auto _result_ = s->wglCreateContextAttribsARB(hdc, hShareContext, attribList);
        s->exit();
        GAPID_DEBUG("wglCreateContextAttribsARB() -- done");
        return _result_;
    } else {
        GAPID_INFO("wglCreateContextAttribsARB at %p: GAPII re-entered. Just invoking imported function at %p", wglCreateContextAttribsARB, s->GlesSpy::imports().wglCreateContextAttribsARB);
        auto _result_ = s->GlesSpy::imports().wglCreateContextAttribsARB(hdc, hShareContext, attribList);
        GAPID_DEBUG("wglCreateContextAttribsARB() -- done");
        return _result_;
    }
}
EXPORT BOOL STDCALL wglMakeCurrent(HDC hdc, HGLRC hglrc) {
    Spy* s = Spy::get();
    GAPID_DEBUG("wglMakeCurrent(%p, %p)", hdc, hglrc);
    if (s->enter("wglMakeCurrent")) {
        auto _result_ = s->wglMakeCurrent(hdc, hglrc);
        s->exit();
        GAPID_DEBUG("wglMakeCurrent() -- done");
        return _result_;
    } else {
        GAPID_INFO("wglMakeCurrent at %p: GAPII re-entered. Just invoking imported function at %p", wglMakeCurrent, s->GlesSpy::imports().wglMakeCurrent);
        auto _result_ = s->GlesSpy::imports().wglMakeCurrent(hdc, hglrc);
        GAPID_DEBUG("wglMakeCurrent() -- done");
        return _result_;
    }
}
EXPORT void STDCALL wglSwapBuffers(HDC hdc) {
    Spy* s = Spy::get();
    GAPID_DEBUG("wglSwapBuffers(%p)", hdc);
    if (s->enter("wglSwapBuffers")) {
        s->wglSwapBuffers(hdc);
        s->exit();
        GAPID_DEBUG("wglSwapBuffers() -- done");
    } else {
        GAPID_INFO("wglSwapBuffers at %p: GAPII re-entered. Just invoking imported function at %p", wglSwapBuffers, s->GlesSpy::imports().wglSwapBuffers);
        s->GlesSpy::imports().wglSwapBuffers(hdc);
        GAPID_DEBUG("wglSwapBuffers() -- done");
    }
}
EXPORT CGLError STDCALL CGLCreateContext(CGLTexelFormatObj pix, CGLContextObj share, CGLContextObj* ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGLCreateContext(%p, %p, %p)", pix, share, ctx);
    if (s->enter("CGLCreateContext")) {
        auto _result_ = s->CGLCreateContext(pix, share, ctx);
        s->exit();
        GAPID_DEBUG("CGLCreateContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("CGLCreateContext at %p: GAPII re-entered. Just invoking imported function at %p", CGLCreateContext, s->GlesSpy::imports().CGLCreateContext);
        auto _result_ = s->GlesSpy::imports().CGLCreateContext(pix, share, ctx);
        GAPID_DEBUG("CGLCreateContext() -- done");
        return _result_;
    }
}
EXPORT CGLError STDCALL CGLSetCurrentContext(CGLContextObj ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGLSetCurrentContext(%p)", ctx);
    if (s->enter("CGLSetCurrentContext")) {
        auto _result_ = s->CGLSetCurrentContext(ctx);
        s->exit();
        GAPID_DEBUG("CGLSetCurrentContext() -- done");
        return _result_;
    } else {
        GAPID_INFO("CGLSetCurrentContext at %p: GAPII re-entered. Just invoking imported function at %p", CGLSetCurrentContext, s->GlesSpy::imports().CGLSetCurrentContext);
        auto _result_ = s->GlesSpy::imports().CGLSetCurrentContext(ctx);
        GAPID_DEBUG("CGLSetCurrentContext() -- done");
        return _result_;
    }
}
EXPORT int STDCALL CGLGetSurface(CGLContextObj ctx, CGSConnectionID* cid, CGSWindowID* wid, CGSSurfaceID* sid) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGLGetSurface(%p, %p, %p, %p)", ctx, cid, wid, sid);
    if (s->enter("CGLGetSurface")) {
        auto _result_ = s->CGLGetSurface(ctx, cid, wid, sid);
        s->exit();
        GAPID_DEBUG("CGLGetSurface() -- done");
        return _result_;
    } else {
        GAPID_INFO("CGLGetSurface at %p: GAPII re-entered. Just invoking imported function at %p", CGLGetSurface, s->GlesSpy::imports().CGLGetSurface);
        auto _result_ = s->GlesSpy::imports().CGLGetSurface(ctx, cid, wid, sid);
        GAPID_DEBUG("CGLGetSurface() -- done");
        return _result_;
    }
}
EXPORT int STDCALL CGSGetSurfaceBounds(CGSConnectionID cid, CGSWindowID wid, CGSSurfaceID sid, double* bounds) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGSGetSurfaceBounds(%p, %" PRId32 ", %" PRId32 ", %p)", cid, wid, sid, bounds);
    if (s->enter("CGSGetSurfaceBounds")) {
        auto _result_ = s->CGSGetSurfaceBounds(cid, wid, sid, bounds);
        s->exit();
        GAPID_DEBUG("CGSGetSurfaceBounds() -- done");
        return _result_;
    } else {
        GAPID_INFO("CGSGetSurfaceBounds at %p: GAPII re-entered. Just invoking imported function at %p", CGSGetSurfaceBounds, s->GlesSpy::imports().CGSGetSurfaceBounds);
        auto _result_ = s->GlesSpy::imports().CGSGetSurfaceBounds(cid, wid, sid, bounds);
        GAPID_DEBUG("CGSGetSurfaceBounds() -- done");
        return _result_;
    }
}
EXPORT CGLError STDCALL CGLFlushDrawable(CGLContextObj ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGLFlushDrawable(%p)", ctx);
    if (s->enter("CGLFlushDrawable")) {
        auto _result_ = s->CGLFlushDrawable(ctx);
        s->exit();
        GAPID_DEBUG("CGLFlushDrawable() -- done");
        return _result_;
    } else {
        GAPID_INFO("CGLFlushDrawable at %p: GAPII re-entered. Just invoking imported function at %p", CGLFlushDrawable, s->GlesSpy::imports().CGLFlushDrawable);
        auto _result_ = s->GlesSpy::imports().CGLFlushDrawable(ctx);
        GAPID_DEBUG("CGLFlushDrawable() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glGetQueryObjecti64v(QueryId query, uint32_t parameter, int64_t* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjecti64v(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjecti64v")) {
        s->glGetQueryObjecti64v(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjecti64v() -- done");
    } else {
        GAPID_INFO("glGetQueryObjecti64v at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjecti64v, s->GlesSpy::imports().glGetQueryObjecti64v);
        s->GlesSpy::imports().glGetQueryObjecti64v(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjecti64v() -- done");
    }
}
EXPORT void STDCALL glGetQueryObjectui64v(QueryId query, uint32_t parameter, uint64_t* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetQueryObjectui64v(%" PRIu32 ", %u, %p)", query, parameter, value);
    if (s->enter("glGetQueryObjectui64v")) {
        s->glGetQueryObjectui64v(query, parameter, value);
        s->exit();
        GAPID_DEBUG("glGetQueryObjectui64v() -- done");
    } else {
        GAPID_INFO("glGetQueryObjectui64v at %p: GAPII re-entered. Just invoking imported function at %p", glGetQueryObjectui64v, s->GlesSpy::imports().glGetQueryObjectui64v);
        s->GlesSpy::imports().glGetQueryObjectui64v(query, parameter, value);
        GAPID_DEBUG("glGetQueryObjectui64v() -- done");
    }
}
EXPORT void STDCALL glAlphaFunc(uint32_t func, GLfloat ref) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glAlphaFunc(%u, %f)", func, ref);
    if (s->enter("glAlphaFunc")) {
        s->glAlphaFunc(func, ref);
        s->exit();
        GAPID_DEBUG("glAlphaFunc() -- done");
    } else {
        GAPID_INFO("glAlphaFunc at %p: GAPII re-entered. Just invoking imported function at %p", glAlphaFunc, s->GlesSpy::imports().glAlphaFunc);
        s->GlesSpy::imports().glAlphaFunc(func, ref);
        GAPID_DEBUG("glAlphaFunc() -- done");
    }
}
EXPORT void STDCALL glAlphaFuncx(uint32_t func, GLfixed ref) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glAlphaFuncx(%u, %" PRId32 ")", func, ref);
    if (s->enter("glAlphaFuncx")) {
        s->glAlphaFuncx(func, ref);
        s->exit();
        GAPID_DEBUG("glAlphaFuncx() -- done");
    } else {
        GAPID_INFO("glAlphaFuncx at %p: GAPII re-entered. Just invoking imported function at %p", glAlphaFuncx, s->GlesSpy::imports().glAlphaFuncx);
        s->GlesSpy::imports().glAlphaFuncx(func, ref);
        GAPID_DEBUG("glAlphaFuncx() -- done");
    }
}
EXPORT void STDCALL glAlphaFuncxOES(uint32_t func, GLfixed ref) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glAlphaFuncxOES(%u, %" PRId32 ")", func, ref);
    if (s->enter("glAlphaFuncxOES")) {
        s->glAlphaFuncxOES(func, ref);
        s->exit();
        GAPID_DEBUG("glAlphaFuncxOES() -- done");
    } else {
        GAPID_INFO("glAlphaFuncxOES at %p: GAPII re-entered. Just invoking imported function at %p", glAlphaFuncxOES, s->GlesSpy::imports().glAlphaFuncxOES);
        s->GlesSpy::imports().glAlphaFuncxOES(func, ref);
        GAPID_DEBUG("glAlphaFuncxOES() -- done");
    }
}
EXPORT void STDCALL glBindFramebufferOES(uint32_t target, GLuint framebuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindFramebufferOES(%u, %" PRIu32 ")", target, framebuffer);
    if (s->enter("glBindFramebufferOES")) {
        s->glBindFramebufferOES(target, framebuffer);
        s->exit();
        GAPID_DEBUG("glBindFramebufferOES() -- done");
    } else {
        GAPID_INFO("glBindFramebufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glBindFramebufferOES, s->GlesSpy::imports().glBindFramebufferOES);
        s->GlesSpy::imports().glBindFramebufferOES(target, framebuffer);
        GAPID_DEBUG("glBindFramebufferOES() -- done");
    }
}
EXPORT void STDCALL glBindRenderbufferOES(uint32_t target, GLuint renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindRenderbufferOES(%u, %" PRIu32 ")", target, renderbuffer);
    if (s->enter("glBindRenderbufferOES")) {
        s->glBindRenderbufferOES(target, renderbuffer);
        s->exit();
        GAPID_DEBUG("glBindRenderbufferOES() -- done");
    } else {
        GAPID_INFO("glBindRenderbufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glBindRenderbufferOES, s->GlesSpy::imports().glBindRenderbufferOES);
        s->GlesSpy::imports().glBindRenderbufferOES(target, renderbuffer);
        GAPID_DEBUG("glBindRenderbufferOES() -- done");
    }
}
EXPORT void STDCALL glBlendEquationOES(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationOES(%u)", mode);
    if (s->enter("glBlendEquationOES")) {
        s->glBlendEquationOES(mode);
        s->exit();
        GAPID_DEBUG("glBlendEquationOES() -- done");
    } else {
        GAPID_INFO("glBlendEquationOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationOES, s->GlesSpy::imports().glBlendEquationOES);
        s->GlesSpy::imports().glBlendEquationOES(mode);
        GAPID_DEBUG("glBlendEquationOES() -- done");
    }
}
EXPORT void STDCALL glBlendEquationSeparateOES(uint32_t modeRGB, uint32_t modeAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationSeparateOES(%u, %u)", modeRGB, modeAlpha);
    if (s->enter("glBlendEquationSeparateOES")) {
        s->glBlendEquationSeparateOES(modeRGB, modeAlpha);
        s->exit();
        GAPID_DEBUG("glBlendEquationSeparateOES() -- done");
    } else {
        GAPID_INFO("glBlendEquationSeparateOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendEquationSeparateOES, s->GlesSpy::imports().glBlendEquationSeparateOES);
        s->GlesSpy::imports().glBlendEquationSeparateOES(modeRGB, modeAlpha);
        GAPID_DEBUG("glBlendEquationSeparateOES() -- done");
    }
}
EXPORT void STDCALL glBlendFuncSeparateOES(uint32_t srcRGB, uint32_t dstRGB, uint32_t srcAlpha, uint32_t dstAlpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendFuncSeparateOES(%u, %u, %u, %u)", srcRGB, dstRGB, srcAlpha, dstAlpha);
    if (s->enter("glBlendFuncSeparateOES")) {
        s->glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
        s->exit();
        GAPID_DEBUG("glBlendFuncSeparateOES() -- done");
    } else {
        GAPID_INFO("glBlendFuncSeparateOES at %p: GAPII re-entered. Just invoking imported function at %p", glBlendFuncSeparateOES, s->GlesSpy::imports().glBlendFuncSeparateOES);
        s->GlesSpy::imports().glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
        GAPID_DEBUG("glBlendFuncSeparateOES() -- done");
    }
}
EXPORT uint32_t STDCALL glCheckFramebufferStatusOES(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCheckFramebufferStatusOES(%u)", target);
    if (s->enter("glCheckFramebufferStatusOES")) {
        auto _result_ = s->glCheckFramebufferStatusOES(target);
        s->exit();
        GAPID_DEBUG("glCheckFramebufferStatusOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glCheckFramebufferStatusOES at %p: GAPII re-entered. Just invoking imported function at %p", glCheckFramebufferStatusOES, s->GlesSpy::imports().glCheckFramebufferStatusOES);
        auto _result_ = s->GlesSpy::imports().glCheckFramebufferStatusOES(target);
        GAPID_DEBUG("glCheckFramebufferStatusOES() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearColorx(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
    if (s->enter("glClearColorx")) {
        s->glClearColorx(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glClearColorx() -- done");
    } else {
        GAPID_INFO("glClearColorx at %p: GAPII re-entered. Just invoking imported function at %p", glClearColorx, s->GlesSpy::imports().glClearColorx);
        s->GlesSpy::imports().glClearColorx(red, green, blue, alpha);
        GAPID_DEBUG("glClearColorx() -- done");
    }
}
EXPORT void STDCALL glClearColorxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearColorxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
    if (s->enter("glClearColorxOES")) {
        s->glClearColorxOES(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glClearColorxOES() -- done");
    } else {
        GAPID_INFO("glClearColorxOES at %p: GAPII re-entered. Just invoking imported function at %p", glClearColorxOES, s->GlesSpy::imports().glClearColorxOES);
        s->GlesSpy::imports().glClearColorxOES(red, green, blue, alpha);
        GAPID_DEBUG("glClearColorxOES() -- done");
    }
}
EXPORT void STDCALL glClearDepthfOES(GLclampf depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthfOES(%f)", depth);
    if (s->enter("glClearDepthfOES")) {
        s->glClearDepthfOES(depth);
        s->exit();
        GAPID_DEBUG("glClearDepthfOES() -- done");
    } else {
        GAPID_INFO("glClearDepthfOES at %p: GAPII re-entered. Just invoking imported function at %p", glClearDepthfOES, s->GlesSpy::imports().glClearDepthfOES);
        s->GlesSpy::imports().glClearDepthfOES(depth);
        GAPID_DEBUG("glClearDepthfOES() -- done");
    }
}
EXPORT void STDCALL glClearDepthx(GLfixed depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthx(%" PRId32 ")", depth);
    if (s->enter("glClearDepthx")) {
        s->glClearDepthx(depth);
        s->exit();
        GAPID_DEBUG("glClearDepthx() -- done");
    } else {
        GAPID_INFO("glClearDepthx at %p: GAPII re-entered. Just invoking imported function at %p", glClearDepthx, s->GlesSpy::imports().glClearDepthx);
        s->GlesSpy::imports().glClearDepthx(depth);
        GAPID_DEBUG("glClearDepthx() -- done");
    }
}
EXPORT void STDCALL glClearDepthxOES(GLfixed depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthxOES(%" PRId32 ")", depth);
    if (s->enter("glClearDepthxOES")) {
        s->glClearDepthxOES(depth);
        s->exit();
        GAPID_DEBUG("glClearDepthxOES() -- done");
    } else {
        GAPID_INFO("glClearDepthxOES at %p: GAPII re-entered. Just invoking imported function at %p", glClearDepthxOES, s->GlesSpy::imports().glClearDepthxOES);
        s->GlesSpy::imports().glClearDepthxOES(depth);
        GAPID_DEBUG("glClearDepthxOES() -- done");
    }
}
EXPORT void STDCALL glClientActiveTexture(uint32_t texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClientActiveTexture(%u)", texture);
    if (s->enter("glClientActiveTexture")) {
        s->glClientActiveTexture(texture);
        s->exit();
        GAPID_DEBUG("glClientActiveTexture() -- done");
    } else {
        GAPID_INFO("glClientActiveTexture at %p: GAPII re-entered. Just invoking imported function at %p", glClientActiveTexture, s->GlesSpy::imports().glClientActiveTexture);
        s->GlesSpy::imports().glClientActiveTexture(texture);
        GAPID_DEBUG("glClientActiveTexture() -- done");
    }
}
EXPORT void STDCALL glClipPlanef(uint32_t p, GLfloat* eqn) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClipPlanef(%u, %p)", p, eqn);
    if (s->enter("glClipPlanef")) {
        s->glClipPlanef(p, eqn);
        s->exit();
        GAPID_DEBUG("glClipPlanef() -- done");
    } else {
        GAPID_INFO("glClipPlanef at %p: GAPII re-entered. Just invoking imported function at %p", glClipPlanef, s->GlesSpy::imports().glClipPlanef);
        s->GlesSpy::imports().glClipPlanef(p, eqn);
        GAPID_DEBUG("glClipPlanef() -- done");
    }
}
EXPORT void STDCALL glClipPlanefIMG(uint32_t p, GLfloat* eqn) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClipPlanefIMG(%u, %p)", p, eqn);
    if (s->enter("glClipPlanefIMG")) {
        s->glClipPlanefIMG(p, eqn);
        s->exit();
        GAPID_DEBUG("glClipPlanefIMG() -- done");
    } else {
        GAPID_INFO("glClipPlanefIMG at %p: GAPII re-entered. Just invoking imported function at %p", glClipPlanefIMG, s->GlesSpy::imports().glClipPlanefIMG);
        s->GlesSpy::imports().glClipPlanefIMG(p, eqn);
        GAPID_DEBUG("glClipPlanefIMG() -- done");
    }
}
EXPORT void STDCALL glClipPlanefOES(uint32_t plane, GLfloat* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClipPlanefOES(%u, %p)", plane, equation);
    if (s->enter("glClipPlanefOES")) {
        s->glClipPlanefOES(plane, equation);
        s->exit();
        GAPID_DEBUG("glClipPlanefOES() -- done");
    } else {
        GAPID_INFO("glClipPlanefOES at %p: GAPII re-entered. Just invoking imported function at %p", glClipPlanefOES, s->GlesSpy::imports().glClipPlanefOES);
        s->GlesSpy::imports().glClipPlanefOES(plane, equation);
        GAPID_DEBUG("glClipPlanefOES() -- done");
    }
}
EXPORT void STDCALL glClipPlanex(uint32_t plane, GLfixed* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClipPlanex(%u, %p)", plane, equation);
    if (s->enter("glClipPlanex")) {
        s->glClipPlanex(plane, equation);
        s->exit();
        GAPID_DEBUG("glClipPlanex() -- done");
    } else {
        GAPID_INFO("glClipPlanex at %p: GAPII re-entered. Just invoking imported function at %p", glClipPlanex, s->GlesSpy::imports().glClipPlanex);
        s->GlesSpy::imports().glClipPlanex(plane, equation);
        GAPID_DEBUG("glClipPlanex() -- done");
    }
}
EXPORT void STDCALL glClipPlanexIMG(uint32_t p, GLfixed* eqn) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClipPlanexIMG(%u, %p)", p, eqn);
    if (s->enter("glClipPlanexIMG")) {
        s->glClipPlanexIMG(p, eqn);
        s->exit();
        GAPID_DEBUG("glClipPlanexIMG() -- done");
    } else {
        GAPID_INFO("glClipPlanexIMG at %p: GAPII re-entered. Just invoking imported function at %p", glClipPlanexIMG, s->GlesSpy::imports().glClipPlanexIMG);
        s->GlesSpy::imports().glClipPlanexIMG(p, eqn);
        GAPID_DEBUG("glClipPlanexIMG() -- done");
    }
}
EXPORT void STDCALL glClipPlanexOES(uint32_t plane, GLfixed* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClipPlanexOES(%u, %p)", plane, equation);
    if (s->enter("glClipPlanexOES")) {
        s->glClipPlanexOES(plane, equation);
        s->exit();
        GAPID_DEBUG("glClipPlanexOES() -- done");
    } else {
        GAPID_INFO("glClipPlanexOES at %p: GAPII re-entered. Just invoking imported function at %p", glClipPlanexOES, s->GlesSpy::imports().glClipPlanexOES);
        s->GlesSpy::imports().glClipPlanexOES(plane, equation);
        GAPID_DEBUG("glClipPlanexOES() -- done");
    }
}
EXPORT void STDCALL glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColor4f(%f, %f, %f, %f)", red, green, blue, alpha);
    if (s->enter("glColor4f")) {
        s->glColor4f(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glColor4f() -- done");
    } else {
        GAPID_INFO("glColor4f at %p: GAPII re-entered. Just invoking imported function at %p", glColor4f, s->GlesSpy::imports().glColor4f);
        s->GlesSpy::imports().glColor4f(red, green, blue, alpha);
        GAPID_DEBUG("glColor4f() -- done");
    }
}
EXPORT void STDCALL glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColor4ub(%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", red, green, blue, alpha);
    if (s->enter("glColor4ub")) {
        s->glColor4ub(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glColor4ub() -- done");
    } else {
        GAPID_INFO("glColor4ub at %p: GAPII re-entered. Just invoking imported function at %p", glColor4ub, s->GlesSpy::imports().glColor4ub);
        s->GlesSpy::imports().glColor4ub(red, green, blue, alpha);
        GAPID_DEBUG("glColor4ub() -- done");
    }
}
EXPORT void STDCALL glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColor4x(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
    if (s->enter("glColor4x")) {
        s->glColor4x(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glColor4x() -- done");
    } else {
        GAPID_INFO("glColor4x at %p: GAPII re-entered. Just invoking imported function at %p", glColor4x, s->GlesSpy::imports().glColor4x);
        s->GlesSpy::imports().glColor4x(red, green, blue, alpha);
        GAPID_DEBUG("glColor4x() -- done");
    }
}
EXPORT void STDCALL glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColor4xOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
    if (s->enter("glColor4xOES")) {
        s->glColor4xOES(red, green, blue, alpha);
        s->exit();
        GAPID_DEBUG("glColor4xOES() -- done");
    } else {
        GAPID_INFO("glColor4xOES at %p: GAPII re-entered. Just invoking imported function at %p", glColor4xOES, s->GlesSpy::imports().glColor4xOES);
        s->GlesSpy::imports().glColor4xOES(red, green, blue, alpha);
        GAPID_DEBUG("glColor4xOES() -- done");
    }
}
EXPORT void STDCALL glColorPointer(GLint size, uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColorPointer(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
    if (s->enter("glColorPointer")) {
        s->glColorPointer(size, type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glColorPointer() -- done");
    } else {
        GAPID_INFO("glColorPointer at %p: GAPII re-entered. Just invoking imported function at %p", glColorPointer, s->GlesSpy::imports().glColorPointer);
        s->GlesSpy::imports().glColorPointer(size, type, stride, pointer);
        GAPID_DEBUG("glColorPointer() -- done");
    }
}
EXPORT void STDCALL glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCurrentPaletteMatrixOES(%" PRIu32 ")", matrixpaletteindex);
    if (s->enter("glCurrentPaletteMatrixOES")) {
        s->glCurrentPaletteMatrixOES(matrixpaletteindex);
        s->exit();
        GAPID_DEBUG("glCurrentPaletteMatrixOES() -- done");
    } else {
        GAPID_INFO("glCurrentPaletteMatrixOES at %p: GAPII re-entered. Just invoking imported function at %p", glCurrentPaletteMatrixOES, s->GlesSpy::imports().glCurrentPaletteMatrixOES);
        s->GlesSpy::imports().glCurrentPaletteMatrixOES(matrixpaletteindex);
        GAPID_DEBUG("glCurrentPaletteMatrixOES() -- done");
    }
}
EXPORT void STDCALL glDeleteFramebuffersOES(GLsizei n, GLuint* framebuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteFramebuffersOES(%" PRId32 ", %p)", n, framebuffers);
    if (s->enter("glDeleteFramebuffersOES")) {
        s->glDeleteFramebuffersOES(n, framebuffers);
        s->exit();
        GAPID_DEBUG("glDeleteFramebuffersOES() -- done");
    } else {
        GAPID_INFO("glDeleteFramebuffersOES at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteFramebuffersOES, s->GlesSpy::imports().glDeleteFramebuffersOES);
        s->GlesSpy::imports().glDeleteFramebuffersOES(n, framebuffers);
        GAPID_DEBUG("glDeleteFramebuffersOES() -- done");
    }
}
EXPORT void STDCALL glDeleteRenderbuffersOES(GLsizei n, GLuint* renderbuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteRenderbuffersOES(%" PRId32 ", %p)", n, renderbuffers);
    if (s->enter("glDeleteRenderbuffersOES")) {
        s->glDeleteRenderbuffersOES(n, renderbuffers);
        s->exit();
        GAPID_DEBUG("glDeleteRenderbuffersOES() -- done");
    } else {
        GAPID_INFO("glDeleteRenderbuffersOES at %p: GAPII re-entered. Just invoking imported function at %p", glDeleteRenderbuffersOES, s->GlesSpy::imports().glDeleteRenderbuffersOES);
        s->GlesSpy::imports().glDeleteRenderbuffersOES(n, renderbuffers);
        GAPID_DEBUG("glDeleteRenderbuffersOES() -- done");
    }
}
EXPORT void STDCALL glDepthRangefOES(GLclampf n, GLclampf f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangefOES(%f, %f)", n, f);
    if (s->enter("glDepthRangefOES")) {
        s->glDepthRangefOES(n, f);
        s->exit();
        GAPID_DEBUG("glDepthRangefOES() -- done");
    } else {
        GAPID_INFO("glDepthRangefOES at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangefOES, s->GlesSpy::imports().glDepthRangefOES);
        s->GlesSpy::imports().glDepthRangefOES(n, f);
        GAPID_DEBUG("glDepthRangefOES() -- done");
    }
}
EXPORT void STDCALL glDepthRangex(GLfixed n, GLfixed f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangex(%" PRId32 ", %" PRId32 ")", n, f);
    if (s->enter("glDepthRangex")) {
        s->glDepthRangex(n, f);
        s->exit();
        GAPID_DEBUG("glDepthRangex() -- done");
    } else {
        GAPID_INFO("glDepthRangex at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangex, s->GlesSpy::imports().glDepthRangex);
        s->GlesSpy::imports().glDepthRangex(n, f);
        GAPID_DEBUG("glDepthRangex() -- done");
    }
}
EXPORT void STDCALL glDepthRangexOES(GLfixed n, GLfixed f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangexOES(%" PRId32 ", %" PRId32 ")", n, f);
    if (s->enter("glDepthRangexOES")) {
        s->glDepthRangexOES(n, f);
        s->exit();
        GAPID_DEBUG("glDepthRangexOES() -- done");
    } else {
        GAPID_INFO("glDepthRangexOES at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangexOES, s->GlesSpy::imports().glDepthRangexOES);
        s->GlesSpy::imports().glDepthRangexOES(n, f);
        GAPID_DEBUG("glDepthRangexOES() -- done");
    }
}
EXPORT void STDCALL glDisableClientState(uint32_t array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableClientState(%u)", array);
    if (s->enter("glDisableClientState")) {
        s->glDisableClientState(array);
        s->exit();
        GAPID_DEBUG("glDisableClientState() -- done");
    } else {
        GAPID_INFO("glDisableClientState at %p: GAPII re-entered. Just invoking imported function at %p", glDisableClientState, s->GlesSpy::imports().glDisableClientState);
        s->GlesSpy::imports().glDisableClientState(array);
        GAPID_DEBUG("glDisableClientState() -- done");
    }
}
EXPORT void STDCALL glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexfOES(%f, %f, %f, %f, %f)", x, y, z, width, height);
    if (s->enter("glDrawTexfOES")) {
        s->glDrawTexfOES(x, y, z, width, height);
        s->exit();
        GAPID_DEBUG("glDrawTexfOES() -- done");
    } else {
        GAPID_INFO("glDrawTexfOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexfOES, s->GlesSpy::imports().glDrawTexfOES);
        s->GlesSpy::imports().glDrawTexfOES(x, y, z, width, height);
        GAPID_DEBUG("glDrawTexfOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexfvOES(GLfloat* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexfvOES(%p)", coords);
    if (s->enter("glDrawTexfvOES")) {
        s->glDrawTexfvOES(coords);
        s->exit();
        GAPID_DEBUG("glDrawTexfvOES() -- done");
    } else {
        GAPID_INFO("glDrawTexfvOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexfvOES, s->GlesSpy::imports().glDrawTexfvOES);
        s->GlesSpy::imports().glDrawTexfvOES(coords);
        GAPID_DEBUG("glDrawTexfvOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexiOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z, width, height);
    if (s->enter("glDrawTexiOES")) {
        s->glDrawTexiOES(x, y, z, width, height);
        s->exit();
        GAPID_DEBUG("glDrawTexiOES() -- done");
    } else {
        GAPID_INFO("glDrawTexiOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexiOES, s->GlesSpy::imports().glDrawTexiOES);
        s->GlesSpy::imports().glDrawTexiOES(x, y, z, width, height);
        GAPID_DEBUG("glDrawTexiOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexivOES(GLint* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexivOES(%p)", coords);
    if (s->enter("glDrawTexivOES")) {
        s->glDrawTexivOES(coords);
        s->exit();
        GAPID_DEBUG("glDrawTexivOES() -- done");
    } else {
        GAPID_INFO("glDrawTexivOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexivOES, s->GlesSpy::imports().glDrawTexivOES);
        s->GlesSpy::imports().glDrawTexivOES(coords);
        GAPID_DEBUG("glDrawTexivOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexsOES(%" PRId16 ", %" PRId16 ", %" PRId16 ", %" PRId16 ", %" PRId16 ")", x, y, z, width, height);
    if (s->enter("glDrawTexsOES")) {
        s->glDrawTexsOES(x, y, z, width, height);
        s->exit();
        GAPID_DEBUG("glDrawTexsOES() -- done");
    } else {
        GAPID_INFO("glDrawTexsOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexsOES, s->GlesSpy::imports().glDrawTexsOES);
        s->GlesSpy::imports().glDrawTexsOES(x, y, z, width, height);
        GAPID_DEBUG("glDrawTexsOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexsvOES(GLshort* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexsvOES(%p)", coords);
    if (s->enter("glDrawTexsvOES")) {
        s->glDrawTexsvOES(coords);
        s->exit();
        GAPID_DEBUG("glDrawTexsvOES() -- done");
    } else {
        GAPID_INFO("glDrawTexsvOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexsvOES, s->GlesSpy::imports().glDrawTexsvOES);
        s->GlesSpy::imports().glDrawTexsvOES(coords);
        GAPID_DEBUG("glDrawTexsvOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z, width, height);
    if (s->enter("glDrawTexxOES")) {
        s->glDrawTexxOES(x, y, z, width, height);
        s->exit();
        GAPID_DEBUG("glDrawTexxOES() -- done");
    } else {
        GAPID_INFO("glDrawTexxOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexxOES, s->GlesSpy::imports().glDrawTexxOES);
        s->GlesSpy::imports().glDrawTexxOES(x, y, z, width, height);
        GAPID_DEBUG("glDrawTexxOES() -- done");
    }
}
EXPORT void STDCALL glDrawTexxvOES(GLfixed* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexxvOES(%p)", coords);
    if (s->enter("glDrawTexxvOES")) {
        s->glDrawTexxvOES(coords);
        s->exit();
        GAPID_DEBUG("glDrawTexxvOES() -- done");
    } else {
        GAPID_INFO("glDrawTexxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTexxvOES, s->GlesSpy::imports().glDrawTexxvOES);
        s->GlesSpy::imports().glDrawTexxvOES(coords);
        GAPID_DEBUG("glDrawTexxvOES() -- done");
    }
}
EXPORT void STDCALL glEnableClientState(uint32_t array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableClientState(%u)", array);
    if (s->enter("glEnableClientState")) {
        s->glEnableClientState(array);
        s->exit();
        GAPID_DEBUG("glEnableClientState() -- done");
    } else {
        GAPID_INFO("glEnableClientState at %p: GAPII re-entered. Just invoking imported function at %p", glEnableClientState, s->GlesSpy::imports().glEnableClientState);
        s->GlesSpy::imports().glEnableClientState(array);
        GAPID_DEBUG("glEnableClientState() -- done");
    }
}
EXPORT void STDCALL glFogf(uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFogf(%u, %f)", pname, param);
    if (s->enter("glFogf")) {
        s->glFogf(pname, param);
        s->exit();
        GAPID_DEBUG("glFogf() -- done");
    } else {
        GAPID_INFO("glFogf at %p: GAPII re-entered. Just invoking imported function at %p", glFogf, s->GlesSpy::imports().glFogf);
        s->GlesSpy::imports().glFogf(pname, param);
        GAPID_DEBUG("glFogf() -- done");
    }
}
EXPORT void STDCALL glFogfv(uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFogfv(%u, %p)", pname, params);
    if (s->enter("glFogfv")) {
        s->glFogfv(pname, params);
        s->exit();
        GAPID_DEBUG("glFogfv() -- done");
    } else {
        GAPID_INFO("glFogfv at %p: GAPII re-entered. Just invoking imported function at %p", glFogfv, s->GlesSpy::imports().glFogfv);
        s->GlesSpy::imports().glFogfv(pname, params);
        GAPID_DEBUG("glFogfv() -- done");
    }
}
EXPORT void STDCALL glFogx(uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFogx(%u, %" PRId32 ")", pname, param);
    if (s->enter("glFogx")) {
        s->glFogx(pname, param);
        s->exit();
        GAPID_DEBUG("glFogx() -- done");
    } else {
        GAPID_INFO("glFogx at %p: GAPII re-entered. Just invoking imported function at %p", glFogx, s->GlesSpy::imports().glFogx);
        s->GlesSpy::imports().glFogx(pname, param);
        GAPID_DEBUG("glFogx() -- done");
    }
}
EXPORT void STDCALL glFogxOES(uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFogxOES(%u, %" PRId32 ")", pname, param);
    if (s->enter("glFogxOES")) {
        s->glFogxOES(pname, param);
        s->exit();
        GAPID_DEBUG("glFogxOES() -- done");
    } else {
        GAPID_INFO("glFogxOES at %p: GAPII re-entered. Just invoking imported function at %p", glFogxOES, s->GlesSpy::imports().glFogxOES);
        s->GlesSpy::imports().glFogxOES(pname, param);
        GAPID_DEBUG("glFogxOES() -- done");
    }
}
EXPORT void STDCALL glFogxv(uint32_t pname, GLfixed* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFogxv(%u, %p)", pname, param);
    if (s->enter("glFogxv")) {
        s->glFogxv(pname, param);
        s->exit();
        GAPID_DEBUG("glFogxv() -- done");
    } else {
        GAPID_INFO("glFogxv at %p: GAPII re-entered. Just invoking imported function at %p", glFogxv, s->GlesSpy::imports().glFogxv);
        s->GlesSpy::imports().glFogxv(pname, param);
        GAPID_DEBUG("glFogxv() -- done");
    }
}
EXPORT void STDCALL glFogxvOES(uint32_t pname, GLfixed* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFogxvOES(%u, %p)", pname, param);
    if (s->enter("glFogxvOES")) {
        s->glFogxvOES(pname, param);
        s->exit();
        GAPID_DEBUG("glFogxvOES() -- done");
    } else {
        GAPID_INFO("glFogxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glFogxvOES, s->GlesSpy::imports().glFogxvOES);
        s->GlesSpy::imports().glFogxvOES(pname, param);
        GAPID_DEBUG("glFogxvOES() -- done");
    }
}
EXPORT void STDCALL glFramebufferRenderbufferOES(uint32_t target, uint32_t attachment, uint32_t renderbuffertarget, GLuint renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferRenderbufferOES(%u, %u, %u, %" PRIu32 ")", target, attachment, renderbuffertarget, renderbuffer);
    if (s->enter("glFramebufferRenderbufferOES")) {
        s->glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
        s->exit();
        GAPID_DEBUG("glFramebufferRenderbufferOES() -- done");
    } else {
        GAPID_INFO("glFramebufferRenderbufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferRenderbufferOES, s->GlesSpy::imports().glFramebufferRenderbufferOES);
        s->GlesSpy::imports().glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
        GAPID_DEBUG("glFramebufferRenderbufferOES() -- done");
    }
}
EXPORT void STDCALL glFramebufferTexture2DOES(uint32_t target, uint32_t attachment, uint32_t textarget, TextureId texture, GLint level) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture2DOES(%u, %u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, textarget, texture, level);
    if (s->enter("glFramebufferTexture2DOES")) {
        s->glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
        s->exit();
        GAPID_DEBUG("glFramebufferTexture2DOES() -- done");
    } else {
        GAPID_INFO("glFramebufferTexture2DOES at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture2DOES, s->GlesSpy::imports().glFramebufferTexture2DOES);
        s->GlesSpy::imports().glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
        GAPID_DEBUG("glFramebufferTexture2DOES() -- done");
    }
}
EXPORT void STDCALL glFrustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFrustumf(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
    if (s->enter("glFrustumf")) {
        s->glFrustumf(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glFrustumf() -- done");
    } else {
        GAPID_INFO("glFrustumf at %p: GAPII re-entered. Just invoking imported function at %p", glFrustumf, s->GlesSpy::imports().glFrustumf);
        s->GlesSpy::imports().glFrustumf(l, r, b, t, n, f);
        GAPID_DEBUG("glFrustumf() -- done");
    }
}
EXPORT void STDCALL glFrustumfOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFrustumfOES(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
    if (s->enter("glFrustumfOES")) {
        s->glFrustumfOES(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glFrustumfOES() -- done");
    } else {
        GAPID_INFO("glFrustumfOES at %p: GAPII re-entered. Just invoking imported function at %p", glFrustumfOES, s->GlesSpy::imports().glFrustumfOES);
        s->GlesSpy::imports().glFrustumfOES(l, r, b, t, n, f);
        GAPID_DEBUG("glFrustumfOES() -- done");
    }
}
EXPORT void STDCALL glFrustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFrustumx(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
    if (s->enter("glFrustumx")) {
        s->glFrustumx(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glFrustumx() -- done");
    } else {
        GAPID_INFO("glFrustumx at %p: GAPII re-entered. Just invoking imported function at %p", glFrustumx, s->GlesSpy::imports().glFrustumx);
        s->GlesSpy::imports().glFrustumx(l, r, b, t, n, f);
        GAPID_DEBUG("glFrustumx() -- done");
    }
}
EXPORT void STDCALL glFrustumxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFrustumxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
    if (s->enter("glFrustumxOES")) {
        s->glFrustumxOES(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glFrustumxOES() -- done");
    } else {
        GAPID_INFO("glFrustumxOES at %p: GAPII re-entered. Just invoking imported function at %p", glFrustumxOES, s->GlesSpy::imports().glFrustumxOES);
        s->GlesSpy::imports().glFrustumxOES(l, r, b, t, n, f);
        GAPID_DEBUG("glFrustumxOES() -- done");
    }
}
EXPORT void STDCALL glGenFramebuffersOES(GLsizei n, GLuint* framebuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenFramebuffersOES(%" PRId32 ", %p)", n, framebuffers);
    if (s->enter("glGenFramebuffersOES")) {
        s->glGenFramebuffersOES(n, framebuffers);
        s->exit();
        GAPID_DEBUG("glGenFramebuffersOES() -- done");
    } else {
        GAPID_INFO("glGenFramebuffersOES at %p: GAPII re-entered. Just invoking imported function at %p", glGenFramebuffersOES, s->GlesSpy::imports().glGenFramebuffersOES);
        s->GlesSpy::imports().glGenFramebuffersOES(n, framebuffers);
        GAPID_DEBUG("glGenFramebuffersOES() -- done");
    }
}
EXPORT void STDCALL glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenRenderbuffersOES(%" PRId32 ", %p)", n, renderbuffers);
    if (s->enter("glGenRenderbuffersOES")) {
        s->glGenRenderbuffersOES(n, renderbuffers);
        s->exit();
        GAPID_DEBUG("glGenRenderbuffersOES() -- done");
    } else {
        GAPID_INFO("glGenRenderbuffersOES at %p: GAPII re-entered. Just invoking imported function at %p", glGenRenderbuffersOES, s->GlesSpy::imports().glGenRenderbuffersOES);
        s->GlesSpy::imports().glGenRenderbuffersOES(n, renderbuffers);
        GAPID_DEBUG("glGenRenderbuffersOES() -- done");
    }
}
EXPORT void STDCALL glGenerateMipmapOES(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenerateMipmapOES(%u)", target);
    if (s->enter("glGenerateMipmapOES")) {
        s->glGenerateMipmapOES(target);
        s->exit();
        GAPID_DEBUG("glGenerateMipmapOES() -- done");
    } else {
        GAPID_INFO("glGenerateMipmapOES at %p: GAPII re-entered. Just invoking imported function at %p", glGenerateMipmapOES, s->GlesSpy::imports().glGenerateMipmapOES);
        s->GlesSpy::imports().glGenerateMipmapOES(target);
        GAPID_DEBUG("glGenerateMipmapOES() -- done");
    }
}
EXPORT void STDCALL glGetClipPlanef(uint32_t plane, GLfloat* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetClipPlanef(%u, %p)", plane, equation);
    if (s->enter("glGetClipPlanef")) {
        s->glGetClipPlanef(plane, equation);
        s->exit();
        GAPID_DEBUG("glGetClipPlanef() -- done");
    } else {
        GAPID_INFO("glGetClipPlanef at %p: GAPII re-entered. Just invoking imported function at %p", glGetClipPlanef, s->GlesSpy::imports().glGetClipPlanef);
        s->GlesSpy::imports().glGetClipPlanef(plane, equation);
        GAPID_DEBUG("glGetClipPlanef() -- done");
    }
}
EXPORT void STDCALL glGetClipPlanefOES(uint32_t plane, GLfloat* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetClipPlanefOES(%u, %p)", plane, equation);
    if (s->enter("glGetClipPlanefOES")) {
        s->glGetClipPlanefOES(plane, equation);
        s->exit();
        GAPID_DEBUG("glGetClipPlanefOES() -- done");
    } else {
        GAPID_INFO("glGetClipPlanefOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetClipPlanefOES, s->GlesSpy::imports().glGetClipPlanefOES);
        s->GlesSpy::imports().glGetClipPlanefOES(plane, equation);
        GAPID_DEBUG("glGetClipPlanefOES() -- done");
    }
}
EXPORT void STDCALL glGetClipPlanex(uint32_t plane, GLfixed* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetClipPlanex(%u, %p)", plane, equation);
    if (s->enter("glGetClipPlanex")) {
        s->glGetClipPlanex(plane, equation);
        s->exit();
        GAPID_DEBUG("glGetClipPlanex() -- done");
    } else {
        GAPID_INFO("glGetClipPlanex at %p: GAPII re-entered. Just invoking imported function at %p", glGetClipPlanex, s->GlesSpy::imports().glGetClipPlanex);
        s->GlesSpy::imports().glGetClipPlanex(plane, equation);
        GAPID_DEBUG("glGetClipPlanex() -- done");
    }
}
EXPORT void STDCALL glGetClipPlanexOES(uint32_t plane, GLfixed* equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetClipPlanexOES(%u, %p)", plane, equation);
    if (s->enter("glGetClipPlanexOES")) {
        s->glGetClipPlanexOES(plane, equation);
        s->exit();
        GAPID_DEBUG("glGetClipPlanexOES() -- done");
    } else {
        GAPID_INFO("glGetClipPlanexOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetClipPlanexOES, s->GlesSpy::imports().glGetClipPlanexOES);
        s->GlesSpy::imports().glGetClipPlanexOES(plane, equation);
        GAPID_DEBUG("glGetClipPlanexOES() -- done");
    }
}
EXPORT void STDCALL glGetFixedv(uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFixedv(%u, %p)", pname, params);
    if (s->enter("glGetFixedv")) {
        s->glGetFixedv(pname, params);
        s->exit();
        GAPID_DEBUG("glGetFixedv() -- done");
    } else {
        GAPID_INFO("glGetFixedv at %p: GAPII re-entered. Just invoking imported function at %p", glGetFixedv, s->GlesSpy::imports().glGetFixedv);
        s->GlesSpy::imports().glGetFixedv(pname, params);
        GAPID_DEBUG("glGetFixedv() -- done");
    }
}
EXPORT void STDCALL glGetFixedvOES(uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFixedvOES(%u, %p)", pname, params);
    if (s->enter("glGetFixedvOES")) {
        s->glGetFixedvOES(pname, params);
        s->exit();
        GAPID_DEBUG("glGetFixedvOES() -- done");
    } else {
        GAPID_INFO("glGetFixedvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetFixedvOES, s->GlesSpy::imports().glGetFixedvOES);
        s->GlesSpy::imports().glGetFixedvOES(pname, params);
        GAPID_DEBUG("glGetFixedvOES() -- done");
    }
}
EXPORT void STDCALL glGetFramebufferAttachmentParameterivOES(uint32_t target, uint32_t attachment, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFramebufferAttachmentParameterivOES(%u, %u, %u, %p)", target, attachment, pname, params);
    if (s->enter("glGetFramebufferAttachmentParameterivOES")) {
        s->glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
        s->exit();
        GAPID_DEBUG("glGetFramebufferAttachmentParameterivOES() -- done");
    } else {
        GAPID_INFO("glGetFramebufferAttachmentParameterivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetFramebufferAttachmentParameterivOES, s->GlesSpy::imports().glGetFramebufferAttachmentParameterivOES);
        s->GlesSpy::imports().glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
        GAPID_DEBUG("glGetFramebufferAttachmentParameterivOES() -- done");
    }
}
EXPORT void STDCALL glGetLightfv(uint32_t light, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetLightfv(%u, %u, %p)", light, pname, params);
    if (s->enter("glGetLightfv")) {
        s->glGetLightfv(light, pname, params);
        s->exit();
        GAPID_DEBUG("glGetLightfv() -- done");
    } else {
        GAPID_INFO("glGetLightfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetLightfv, s->GlesSpy::imports().glGetLightfv);
        s->GlesSpy::imports().glGetLightfv(light, pname, params);
        GAPID_DEBUG("glGetLightfv() -- done");
    }
}
EXPORT void STDCALL glGetLightxv(uint32_t light, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetLightxv(%u, %u, %p)", light, pname, params);
    if (s->enter("glGetLightxv")) {
        s->glGetLightxv(light, pname, params);
        s->exit();
        GAPID_DEBUG("glGetLightxv() -- done");
    } else {
        GAPID_INFO("glGetLightxv at %p: GAPII re-entered. Just invoking imported function at %p", glGetLightxv, s->GlesSpy::imports().glGetLightxv);
        s->GlesSpy::imports().glGetLightxv(light, pname, params);
        GAPID_DEBUG("glGetLightxv() -- done");
    }
}
EXPORT void STDCALL glGetLightxvOES(uint32_t light, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetLightxvOES(%u, %u, %p)", light, pname, params);
    if (s->enter("glGetLightxvOES")) {
        s->glGetLightxvOES(light, pname, params);
        s->exit();
        GAPID_DEBUG("glGetLightxvOES() -- done");
    } else {
        GAPID_INFO("glGetLightxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetLightxvOES, s->GlesSpy::imports().glGetLightxvOES);
        s->GlesSpy::imports().glGetLightxvOES(light, pname, params);
        GAPID_DEBUG("glGetLightxvOES() -- done");
    }
}
EXPORT void STDCALL glGetMaterialfv(uint32_t face, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetMaterialfv(%u, %u, %p)", face, pname, params);
    if (s->enter("glGetMaterialfv")) {
        s->glGetMaterialfv(face, pname, params);
        s->exit();
        GAPID_DEBUG("glGetMaterialfv() -- done");
    } else {
        GAPID_INFO("glGetMaterialfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetMaterialfv, s->GlesSpy::imports().glGetMaterialfv);
        s->GlesSpy::imports().glGetMaterialfv(face, pname, params);
        GAPID_DEBUG("glGetMaterialfv() -- done");
    }
}
EXPORT void STDCALL glGetMaterialxv(uint32_t face, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetMaterialxv(%u, %u, %p)", face, pname, params);
    if (s->enter("glGetMaterialxv")) {
        s->glGetMaterialxv(face, pname, params);
        s->exit();
        GAPID_DEBUG("glGetMaterialxv() -- done");
    } else {
        GAPID_INFO("glGetMaterialxv at %p: GAPII re-entered. Just invoking imported function at %p", glGetMaterialxv, s->GlesSpy::imports().glGetMaterialxv);
        s->GlesSpy::imports().glGetMaterialxv(face, pname, params);
        GAPID_DEBUG("glGetMaterialxv() -- done");
    }
}
EXPORT void STDCALL glGetMaterialxvOES(uint32_t face, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetMaterialxvOES(%u, %u, %p)", face, pname, params);
    if (s->enter("glGetMaterialxvOES")) {
        s->glGetMaterialxvOES(face, pname, params);
        s->exit();
        GAPID_DEBUG("glGetMaterialxvOES() -- done");
    } else {
        GAPID_INFO("glGetMaterialxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetMaterialxvOES, s->GlesSpy::imports().glGetMaterialxvOES);
        s->GlesSpy::imports().glGetMaterialxvOES(face, pname, params);
        GAPID_DEBUG("glGetMaterialxvOES() -- done");
    }
}
EXPORT void STDCALL glGetRenderbufferParameterivOES(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetRenderbufferParameterivOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetRenderbufferParameterivOES")) {
        s->glGetRenderbufferParameterivOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetRenderbufferParameterivOES() -- done");
    } else {
        GAPID_INFO("glGetRenderbufferParameterivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetRenderbufferParameterivOES, s->GlesSpy::imports().glGetRenderbufferParameterivOES);
        s->GlesSpy::imports().glGetRenderbufferParameterivOES(target, pname, params);
        GAPID_DEBUG("glGetRenderbufferParameterivOES() -- done");
    }
}
EXPORT void STDCALL glGetTexEnvfv(uint32_t target, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexEnvfv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexEnvfv")) {
        s->glGetTexEnvfv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexEnvfv() -- done");
    } else {
        GAPID_INFO("glGetTexEnvfv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexEnvfv, s->GlesSpy::imports().glGetTexEnvfv);
        s->GlesSpy::imports().glGetTexEnvfv(target, pname, params);
        GAPID_DEBUG("glGetTexEnvfv() -- done");
    }
}
EXPORT void STDCALL glGetTexEnviv(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexEnviv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexEnviv")) {
        s->glGetTexEnviv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexEnviv() -- done");
    } else {
        GAPID_INFO("glGetTexEnviv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexEnviv, s->GlesSpy::imports().glGetTexEnviv);
        s->GlesSpy::imports().glGetTexEnviv(target, pname, params);
        GAPID_DEBUG("glGetTexEnviv() -- done");
    }
}
EXPORT void STDCALL glGetTexEnvxv(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexEnvxv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexEnvxv")) {
        s->glGetTexEnvxv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexEnvxv() -- done");
    } else {
        GAPID_INFO("glGetTexEnvxv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexEnvxv, s->GlesSpy::imports().glGetTexEnvxv);
        s->GlesSpy::imports().glGetTexEnvxv(target, pname, params);
        GAPID_DEBUG("glGetTexEnvxv() -- done");
    }
}
EXPORT void STDCALL glGetTexEnvxvOES(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexEnvxvOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexEnvxvOES")) {
        s->glGetTexEnvxvOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexEnvxvOES() -- done");
    } else {
        GAPID_INFO("glGetTexEnvxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexEnvxvOES, s->GlesSpy::imports().glGetTexEnvxvOES);
        s->GlesSpy::imports().glGetTexEnvxvOES(target, pname, params);
        GAPID_DEBUG("glGetTexEnvxvOES() -- done");
    }
}
EXPORT void STDCALL glGetTexGenfvOES(uint32_t coord, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexGenfvOES(%u, %u, %p)", coord, pname, params);
    if (s->enter("glGetTexGenfvOES")) {
        s->glGetTexGenfvOES(coord, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexGenfvOES() -- done");
    } else {
        GAPID_INFO("glGetTexGenfvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexGenfvOES, s->GlesSpy::imports().glGetTexGenfvOES);
        s->GlesSpy::imports().glGetTexGenfvOES(coord, pname, params);
        GAPID_DEBUG("glGetTexGenfvOES() -- done");
    }
}
EXPORT void STDCALL glGetTexGenivOES(uint32_t coord, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexGenivOES(%u, %u, %p)", coord, pname, params);
    if (s->enter("glGetTexGenivOES")) {
        s->glGetTexGenivOES(coord, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexGenivOES() -- done");
    } else {
        GAPID_INFO("glGetTexGenivOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexGenivOES, s->GlesSpy::imports().glGetTexGenivOES);
        s->GlesSpy::imports().glGetTexGenivOES(coord, pname, params);
        GAPID_DEBUG("glGetTexGenivOES() -- done");
    }
}
EXPORT void STDCALL glGetTexGenxvOES(uint32_t coord, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexGenxvOES(%u, %u, %p)", coord, pname, params);
    if (s->enter("glGetTexGenxvOES")) {
        s->glGetTexGenxvOES(coord, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexGenxvOES() -- done");
    } else {
        GAPID_INFO("glGetTexGenxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexGenxvOES, s->GlesSpy::imports().glGetTexGenxvOES);
        s->GlesSpy::imports().glGetTexGenxvOES(coord, pname, params);
        GAPID_DEBUG("glGetTexGenxvOES() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterxv(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterxv(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterxv")) {
        s->glGetTexParameterxv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterxv() -- done");
    } else {
        GAPID_INFO("glGetTexParameterxv at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterxv, s->GlesSpy::imports().glGetTexParameterxv);
        s->GlesSpy::imports().glGetTexParameterxv(target, pname, params);
        GAPID_DEBUG("glGetTexParameterxv() -- done");
    }
}
EXPORT void STDCALL glGetTexParameterxvOES(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTexParameterxvOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glGetTexParameterxvOES")) {
        s->glGetTexParameterxvOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glGetTexParameterxvOES() -- done");
    } else {
        GAPID_INFO("glGetTexParameterxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetTexParameterxvOES, s->GlesSpy::imports().glGetTexParameterxvOES);
        s->GlesSpy::imports().glGetTexParameterxvOES(target, pname, params);
        GAPID_DEBUG("glGetTexParameterxvOES() -- done");
    }
}
EXPORT GLboolean STDCALL glIsFramebufferOES(GLuint framebuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsFramebufferOES(%" PRIu32 ")", framebuffer);
    if (s->enter("glIsFramebufferOES")) {
        auto _result_ = s->glIsFramebufferOES(framebuffer);
        s->exit();
        GAPID_DEBUG("glIsFramebufferOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsFramebufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glIsFramebufferOES, s->GlesSpy::imports().glIsFramebufferOES);
        auto _result_ = s->GlesSpy::imports().glIsFramebufferOES(framebuffer);
        GAPID_DEBUG("glIsFramebufferOES() -- done");
        return _result_;
    }
}
EXPORT GLboolean STDCALL glIsRenderbufferOES(GLuint renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsRenderbufferOES(%" PRIu32 ")", renderbuffer);
    if (s->enter("glIsRenderbufferOES")) {
        auto _result_ = s->glIsRenderbufferOES(renderbuffer);
        s->exit();
        GAPID_DEBUG("glIsRenderbufferOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glIsRenderbufferOES at %p: GAPII re-entered. Just invoking imported function at %p", glIsRenderbufferOES, s->GlesSpy::imports().glIsRenderbufferOES);
        auto _result_ = s->GlesSpy::imports().glIsRenderbufferOES(renderbuffer);
        GAPID_DEBUG("glIsRenderbufferOES() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glLightModelf(uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightModelf(%u, %f)", pname, param);
    if (s->enter("glLightModelf")) {
        s->glLightModelf(pname, param);
        s->exit();
        GAPID_DEBUG("glLightModelf() -- done");
    } else {
        GAPID_INFO("glLightModelf at %p: GAPII re-entered. Just invoking imported function at %p", glLightModelf, s->GlesSpy::imports().glLightModelf);
        s->GlesSpy::imports().glLightModelf(pname, param);
        GAPID_DEBUG("glLightModelf() -- done");
    }
}
EXPORT void STDCALL glLightModelfv(uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightModelfv(%u, %p)", pname, params);
    if (s->enter("glLightModelfv")) {
        s->glLightModelfv(pname, params);
        s->exit();
        GAPID_DEBUG("glLightModelfv() -- done");
    } else {
        GAPID_INFO("glLightModelfv at %p: GAPII re-entered. Just invoking imported function at %p", glLightModelfv, s->GlesSpy::imports().glLightModelfv);
        s->GlesSpy::imports().glLightModelfv(pname, params);
        GAPID_DEBUG("glLightModelfv() -- done");
    }
}
EXPORT void STDCALL glLightModelx(uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightModelx(%u, %" PRId32 ")", pname, param);
    if (s->enter("glLightModelx")) {
        s->glLightModelx(pname, param);
        s->exit();
        GAPID_DEBUG("glLightModelx() -- done");
    } else {
        GAPID_INFO("glLightModelx at %p: GAPII re-entered. Just invoking imported function at %p", glLightModelx, s->GlesSpy::imports().glLightModelx);
        s->GlesSpy::imports().glLightModelx(pname, param);
        GAPID_DEBUG("glLightModelx() -- done");
    }
}
EXPORT void STDCALL glLightModelxOES(uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightModelxOES(%u, %" PRId32 ")", pname, param);
    if (s->enter("glLightModelxOES")) {
        s->glLightModelxOES(pname, param);
        s->exit();
        GAPID_DEBUG("glLightModelxOES() -- done");
    } else {
        GAPID_INFO("glLightModelxOES at %p: GAPII re-entered. Just invoking imported function at %p", glLightModelxOES, s->GlesSpy::imports().glLightModelxOES);
        s->GlesSpy::imports().glLightModelxOES(pname, param);
        GAPID_DEBUG("glLightModelxOES() -- done");
    }
}
EXPORT void STDCALL glLightModelxv(uint32_t pname, GLfixed* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightModelxv(%u, %p)", pname, param);
    if (s->enter("glLightModelxv")) {
        s->glLightModelxv(pname, param);
        s->exit();
        GAPID_DEBUG("glLightModelxv() -- done");
    } else {
        GAPID_INFO("glLightModelxv at %p: GAPII re-entered. Just invoking imported function at %p", glLightModelxv, s->GlesSpy::imports().glLightModelxv);
        s->GlesSpy::imports().glLightModelxv(pname, param);
        GAPID_DEBUG("glLightModelxv() -- done");
    }
}
EXPORT void STDCALL glLightModelxvOES(uint32_t pname, GLfixed* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightModelxvOES(%u, %p)", pname, param);
    if (s->enter("glLightModelxvOES")) {
        s->glLightModelxvOES(pname, param);
        s->exit();
        GAPID_DEBUG("glLightModelxvOES() -- done");
    } else {
        GAPID_INFO("glLightModelxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glLightModelxvOES, s->GlesSpy::imports().glLightModelxvOES);
        s->GlesSpy::imports().glLightModelxvOES(pname, param);
        GAPID_DEBUG("glLightModelxvOES() -- done");
    }
}
EXPORT void STDCALL glLightf(uint32_t light, uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightf(%u, %u, %f)", light, pname, param);
    if (s->enter("glLightf")) {
        s->glLightf(light, pname, param);
        s->exit();
        GAPID_DEBUG("glLightf() -- done");
    } else {
        GAPID_INFO("glLightf at %p: GAPII re-entered. Just invoking imported function at %p", glLightf, s->GlesSpy::imports().glLightf);
        s->GlesSpy::imports().glLightf(light, pname, param);
        GAPID_DEBUG("glLightf() -- done");
    }
}
EXPORT void STDCALL glLightfv(uint32_t light, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightfv(%u, %u, %p)", light, pname, params);
    if (s->enter("glLightfv")) {
        s->glLightfv(light, pname, params);
        s->exit();
        GAPID_DEBUG("glLightfv() -- done");
    } else {
        GAPID_INFO("glLightfv at %p: GAPII re-entered. Just invoking imported function at %p", glLightfv, s->GlesSpy::imports().glLightfv);
        s->GlesSpy::imports().glLightfv(light, pname, params);
        GAPID_DEBUG("glLightfv() -- done");
    }
}
EXPORT void STDCALL glLightx(uint32_t light, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightx(%u, %u, %" PRId32 ")", light, pname, param);
    if (s->enter("glLightx")) {
        s->glLightx(light, pname, param);
        s->exit();
        GAPID_DEBUG("glLightx() -- done");
    } else {
        GAPID_INFO("glLightx at %p: GAPII re-entered. Just invoking imported function at %p", glLightx, s->GlesSpy::imports().glLightx);
        s->GlesSpy::imports().glLightx(light, pname, param);
        GAPID_DEBUG("glLightx() -- done");
    }
}
EXPORT void STDCALL glLightxOES(uint32_t light, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightxOES(%u, %u, %" PRId32 ")", light, pname, param);
    if (s->enter("glLightxOES")) {
        s->glLightxOES(light, pname, param);
        s->exit();
        GAPID_DEBUG("glLightxOES() -- done");
    } else {
        GAPID_INFO("glLightxOES at %p: GAPII re-entered. Just invoking imported function at %p", glLightxOES, s->GlesSpy::imports().glLightxOES);
        s->GlesSpy::imports().glLightxOES(light, pname, param);
        GAPID_DEBUG("glLightxOES() -- done");
    }
}
EXPORT void STDCALL glLightxv(uint32_t light, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightxv(%u, %u, %p)", light, pname, params);
    if (s->enter("glLightxv")) {
        s->glLightxv(light, pname, params);
        s->exit();
        GAPID_DEBUG("glLightxv() -- done");
    } else {
        GAPID_INFO("glLightxv at %p: GAPII re-entered. Just invoking imported function at %p", glLightxv, s->GlesSpy::imports().glLightxv);
        s->GlesSpy::imports().glLightxv(light, pname, params);
        GAPID_DEBUG("glLightxv() -- done");
    }
}
EXPORT void STDCALL glLightxvOES(uint32_t light, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLightxvOES(%u, %u, %p)", light, pname, params);
    if (s->enter("glLightxvOES")) {
        s->glLightxvOES(light, pname, params);
        s->exit();
        GAPID_DEBUG("glLightxvOES() -- done");
    } else {
        GAPID_INFO("glLightxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glLightxvOES, s->GlesSpy::imports().glLightxvOES);
        s->GlesSpy::imports().glLightxvOES(light, pname, params);
        GAPID_DEBUG("glLightxvOES() -- done");
    }
}
EXPORT void STDCALL glLineWidthx(GLfixed width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLineWidthx(%" PRId32 ")", width);
    if (s->enter("glLineWidthx")) {
        s->glLineWidthx(width);
        s->exit();
        GAPID_DEBUG("glLineWidthx() -- done");
    } else {
        GAPID_INFO("glLineWidthx at %p: GAPII re-entered. Just invoking imported function at %p", glLineWidthx, s->GlesSpy::imports().glLineWidthx);
        s->GlesSpy::imports().glLineWidthx(width);
        GAPID_DEBUG("glLineWidthx() -- done");
    }
}
EXPORT void STDCALL glLineWidthxOES(GLfixed width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLineWidthxOES(%" PRId32 ")", width);
    if (s->enter("glLineWidthxOES")) {
        s->glLineWidthxOES(width);
        s->exit();
        GAPID_DEBUG("glLineWidthxOES() -- done");
    } else {
        GAPID_INFO("glLineWidthxOES at %p: GAPII re-entered. Just invoking imported function at %p", glLineWidthxOES, s->GlesSpy::imports().glLineWidthxOES);
        s->GlesSpy::imports().glLineWidthxOES(width);
        GAPID_DEBUG("glLineWidthxOES() -- done");
    }
}
EXPORT void STDCALL glLoadIdentity() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadIdentity()");
    if (s->enter("glLoadIdentity")) {
        s->glLoadIdentity();
        s->exit();
        GAPID_DEBUG("glLoadIdentity() -- done");
    } else {
        GAPID_INFO("glLoadIdentity at %p: GAPII re-entered. Just invoking imported function at %p", glLoadIdentity, s->GlesSpy::imports().glLoadIdentity);
        s->GlesSpy::imports().glLoadIdentity();
        GAPID_DEBUG("glLoadIdentity() -- done");
    }
}
EXPORT void STDCALL glLoadMatrixf(GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadMatrixf(%p)", m);
    if (s->enter("glLoadMatrixf")) {
        s->glLoadMatrixf(m);
        s->exit();
        GAPID_DEBUG("glLoadMatrixf() -- done");
    } else {
        GAPID_INFO("glLoadMatrixf at %p: GAPII re-entered. Just invoking imported function at %p", glLoadMatrixf, s->GlesSpy::imports().glLoadMatrixf);
        s->GlesSpy::imports().glLoadMatrixf(m);
        GAPID_DEBUG("glLoadMatrixf() -- done");
    }
}
EXPORT void STDCALL glLoadMatrixx(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadMatrixx(%p)", m);
    if (s->enter("glLoadMatrixx")) {
        s->glLoadMatrixx(m);
        s->exit();
        GAPID_DEBUG("glLoadMatrixx() -- done");
    } else {
        GAPID_INFO("glLoadMatrixx at %p: GAPII re-entered. Just invoking imported function at %p", glLoadMatrixx, s->GlesSpy::imports().glLoadMatrixx);
        s->GlesSpy::imports().glLoadMatrixx(m);
        GAPID_DEBUG("glLoadMatrixx() -- done");
    }
}
EXPORT void STDCALL glLoadMatrixxOES(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadMatrixxOES(%p)", m);
    if (s->enter("glLoadMatrixxOES")) {
        s->glLoadMatrixxOES(m);
        s->exit();
        GAPID_DEBUG("glLoadMatrixxOES() -- done");
    } else {
        GAPID_INFO("glLoadMatrixxOES at %p: GAPII re-entered. Just invoking imported function at %p", glLoadMatrixxOES, s->GlesSpy::imports().glLoadMatrixxOES);
        s->GlesSpy::imports().glLoadMatrixxOES(m);
        GAPID_DEBUG("glLoadMatrixxOES() -- done");
    }
}
EXPORT void STDCALL glLoadPaletteFromModelViewMatrixOES() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadPaletteFromModelViewMatrixOES()");
    if (s->enter("glLoadPaletteFromModelViewMatrixOES")) {
        s->glLoadPaletteFromModelViewMatrixOES();
        s->exit();
        GAPID_DEBUG("glLoadPaletteFromModelViewMatrixOES() -- done");
    } else {
        GAPID_INFO("glLoadPaletteFromModelViewMatrixOES at %p: GAPII re-entered. Just invoking imported function at %p", glLoadPaletteFromModelViewMatrixOES, s->GlesSpy::imports().glLoadPaletteFromModelViewMatrixOES);
        s->GlesSpy::imports().glLoadPaletteFromModelViewMatrixOES();
        GAPID_DEBUG("glLoadPaletteFromModelViewMatrixOES() -- done");
    }
}
EXPORT void STDCALL glLogicOp(uint32_t opcode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLogicOp(%u)", opcode);
    if (s->enter("glLogicOp")) {
        s->glLogicOp(opcode);
        s->exit();
        GAPID_DEBUG("glLogicOp() -- done");
    } else {
        GAPID_INFO("glLogicOp at %p: GAPII re-entered. Just invoking imported function at %p", glLogicOp, s->GlesSpy::imports().glLogicOp);
        s->GlesSpy::imports().glLogicOp(opcode);
        GAPID_DEBUG("glLogicOp() -- done");
    }
}
EXPORT void STDCALL glMaterialf(uint32_t face, uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMaterialf(%u, %u, %f)", face, pname, param);
    if (s->enter("glMaterialf")) {
        s->glMaterialf(face, pname, param);
        s->exit();
        GAPID_DEBUG("glMaterialf() -- done");
    } else {
        GAPID_INFO("glMaterialf at %p: GAPII re-entered. Just invoking imported function at %p", glMaterialf, s->GlesSpy::imports().glMaterialf);
        s->GlesSpy::imports().glMaterialf(face, pname, param);
        GAPID_DEBUG("glMaterialf() -- done");
    }
}
EXPORT void STDCALL glMaterialfv(uint32_t face, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMaterialfv(%u, %u, %p)", face, pname, params);
    if (s->enter("glMaterialfv")) {
        s->glMaterialfv(face, pname, params);
        s->exit();
        GAPID_DEBUG("glMaterialfv() -- done");
    } else {
        GAPID_INFO("glMaterialfv at %p: GAPII re-entered. Just invoking imported function at %p", glMaterialfv, s->GlesSpy::imports().glMaterialfv);
        s->GlesSpy::imports().glMaterialfv(face, pname, params);
        GAPID_DEBUG("glMaterialfv() -- done");
    }
}
EXPORT void STDCALL glMaterialx(uint32_t face, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMaterialx(%u, %u, %" PRId32 ")", face, pname, param);
    if (s->enter("glMaterialx")) {
        s->glMaterialx(face, pname, param);
        s->exit();
        GAPID_DEBUG("glMaterialx() -- done");
    } else {
        GAPID_INFO("glMaterialx at %p: GAPII re-entered. Just invoking imported function at %p", glMaterialx, s->GlesSpy::imports().glMaterialx);
        s->GlesSpy::imports().glMaterialx(face, pname, param);
        GAPID_DEBUG("glMaterialx() -- done");
    }
}
EXPORT void STDCALL glMaterialxOES(uint32_t face, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMaterialxOES(%u, %u, %" PRId32 ")", face, pname, param);
    if (s->enter("glMaterialxOES")) {
        s->glMaterialxOES(face, pname, param);
        s->exit();
        GAPID_DEBUG("glMaterialxOES() -- done");
    } else {
        GAPID_INFO("glMaterialxOES at %p: GAPII re-entered. Just invoking imported function at %p", glMaterialxOES, s->GlesSpy::imports().glMaterialxOES);
        s->GlesSpy::imports().glMaterialxOES(face, pname, param);
        GAPID_DEBUG("glMaterialxOES() -- done");
    }
}
EXPORT void STDCALL glMaterialxv(uint32_t face, uint32_t pname, GLfixed* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMaterialxv(%u, %u, %p)", face, pname, param);
    if (s->enter("glMaterialxv")) {
        s->glMaterialxv(face, pname, param);
        s->exit();
        GAPID_DEBUG("glMaterialxv() -- done");
    } else {
        GAPID_INFO("glMaterialxv at %p: GAPII re-entered. Just invoking imported function at %p", glMaterialxv, s->GlesSpy::imports().glMaterialxv);
        s->GlesSpy::imports().glMaterialxv(face, pname, param);
        GAPID_DEBUG("glMaterialxv() -- done");
    }
}
EXPORT void STDCALL glMaterialxvOES(uint32_t face, uint32_t pname, GLfixed* param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMaterialxvOES(%u, %u, %p)", face, pname, param);
    if (s->enter("glMaterialxvOES")) {
        s->glMaterialxvOES(face, pname, param);
        s->exit();
        GAPID_DEBUG("glMaterialxvOES() -- done");
    } else {
        GAPID_INFO("glMaterialxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glMaterialxvOES, s->GlesSpy::imports().glMaterialxvOES);
        s->GlesSpy::imports().glMaterialxvOES(face, pname, param);
        GAPID_DEBUG("glMaterialxvOES() -- done");
    }
}
EXPORT void STDCALL glMatrixIndexPointerOES(GLint size, uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixIndexPointerOES(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
    if (s->enter("glMatrixIndexPointerOES")) {
        s->glMatrixIndexPointerOES(size, type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glMatrixIndexPointerOES() -- done");
    } else {
        GAPID_INFO("glMatrixIndexPointerOES at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixIndexPointerOES, s->GlesSpy::imports().glMatrixIndexPointerOES);
        s->GlesSpy::imports().glMatrixIndexPointerOES(size, type, stride, pointer);
        GAPID_DEBUG("glMatrixIndexPointerOES() -- done");
    }
}
EXPORT void STDCALL glMatrixMode(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixMode(%u)", mode);
    if (s->enter("glMatrixMode")) {
        s->glMatrixMode(mode);
        s->exit();
        GAPID_DEBUG("glMatrixMode() -- done");
    } else {
        GAPID_INFO("glMatrixMode at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixMode, s->GlesSpy::imports().glMatrixMode);
        s->GlesSpy::imports().glMatrixMode(mode);
        GAPID_DEBUG("glMatrixMode() -- done");
    }
}
EXPORT void STDCALL glMultMatrixf(GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultMatrixf(%p)", m);
    if (s->enter("glMultMatrixf")) {
        s->glMultMatrixf(m);
        s->exit();
        GAPID_DEBUG("glMultMatrixf() -- done");
    } else {
        GAPID_INFO("glMultMatrixf at %p: GAPII re-entered. Just invoking imported function at %p", glMultMatrixf, s->GlesSpy::imports().glMultMatrixf);
        s->GlesSpy::imports().glMultMatrixf(m);
        GAPID_DEBUG("glMultMatrixf() -- done");
    }
}
EXPORT void STDCALL glMultMatrixx(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultMatrixx(%p)", m);
    if (s->enter("glMultMatrixx")) {
        s->glMultMatrixx(m);
        s->exit();
        GAPID_DEBUG("glMultMatrixx() -- done");
    } else {
        GAPID_INFO("glMultMatrixx at %p: GAPII re-entered. Just invoking imported function at %p", glMultMatrixx, s->GlesSpy::imports().glMultMatrixx);
        s->GlesSpy::imports().glMultMatrixx(m);
        GAPID_DEBUG("glMultMatrixx() -- done");
    }
}
EXPORT void STDCALL glMultMatrixxOES(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultMatrixxOES(%p)", m);
    if (s->enter("glMultMatrixxOES")) {
        s->glMultMatrixxOES(m);
        s->exit();
        GAPID_DEBUG("glMultMatrixxOES() -- done");
    } else {
        GAPID_INFO("glMultMatrixxOES at %p: GAPII re-entered. Just invoking imported function at %p", glMultMatrixxOES, s->GlesSpy::imports().glMultMatrixxOES);
        s->GlesSpy::imports().glMultMatrixxOES(m);
        GAPID_DEBUG("glMultMatrixxOES() -- done");
    }
}
EXPORT void STDCALL glMultiTexCoord4f(uint32_t target, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiTexCoord4f(%u, %f, %f, %f, %f)", target, v0, v1, v2, v3);
    if (s->enter("glMultiTexCoord4f")) {
        s->glMultiTexCoord4f(target, v0, v1, v2, v3);
        s->exit();
        GAPID_DEBUG("glMultiTexCoord4f() -- done");
    } else {
        GAPID_INFO("glMultiTexCoord4f at %p: GAPII re-entered. Just invoking imported function at %p", glMultiTexCoord4f, s->GlesSpy::imports().glMultiTexCoord4f);
        s->GlesSpy::imports().glMultiTexCoord4f(target, v0, v1, v2, v3);
        GAPID_DEBUG("glMultiTexCoord4f() -- done");
    }
}
EXPORT void STDCALL glMultiTexCoord4x(uint32_t texture, GLfixed v0, GLfixed v1, GLfixed v2, GLfixed v3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiTexCoord4x(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, v0, v1, v2, v3);
    if (s->enter("glMultiTexCoord4x")) {
        s->glMultiTexCoord4x(texture, v0, v1, v2, v3);
        s->exit();
        GAPID_DEBUG("glMultiTexCoord4x() -- done");
    } else {
        GAPID_INFO("glMultiTexCoord4x at %p: GAPII re-entered. Just invoking imported function at %p", glMultiTexCoord4x, s->GlesSpy::imports().glMultiTexCoord4x);
        s->GlesSpy::imports().glMultiTexCoord4x(texture, v0, v1, v2, v3);
        GAPID_DEBUG("glMultiTexCoord4x() -- done");
    }
}
EXPORT void STDCALL glMultiTexCoord4xOES(uint32_t texture, GLfixed v0, GLfixed v1, GLfixed v2, GLfixed v3) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultiTexCoord4xOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, v0, v1, v2, v3);
    if (s->enter("glMultiTexCoord4xOES")) {
        s->glMultiTexCoord4xOES(texture, v0, v1, v2, v3);
        s->exit();
        GAPID_DEBUG("glMultiTexCoord4xOES() -- done");
    } else {
        GAPID_INFO("glMultiTexCoord4xOES at %p: GAPII re-entered. Just invoking imported function at %p", glMultiTexCoord4xOES, s->GlesSpy::imports().glMultiTexCoord4xOES);
        s->GlesSpy::imports().glMultiTexCoord4xOES(texture, v0, v1, v2, v3);
        GAPID_DEBUG("glMultiTexCoord4xOES() -- done");
    }
}
EXPORT void STDCALL glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glNormal3f(%f, %f, %f)", nx, ny, nz);
    if (s->enter("glNormal3f")) {
        s->glNormal3f(nx, ny, nz);
        s->exit();
        GAPID_DEBUG("glNormal3f() -- done");
    } else {
        GAPID_INFO("glNormal3f at %p: GAPII re-entered. Just invoking imported function at %p", glNormal3f, s->GlesSpy::imports().glNormal3f);
        s->GlesSpy::imports().glNormal3f(nx, ny, nz);
        GAPID_DEBUG("glNormal3f() -- done");
    }
}
EXPORT void STDCALL glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glNormal3x(%" PRId32 ", %" PRId32 ", %" PRId32 ")", nx, ny, nz);
    if (s->enter("glNormal3x")) {
        s->glNormal3x(nx, ny, nz);
        s->exit();
        GAPID_DEBUG("glNormal3x() -- done");
    } else {
        GAPID_INFO("glNormal3x at %p: GAPII re-entered. Just invoking imported function at %p", glNormal3x, s->GlesSpy::imports().glNormal3x);
        s->GlesSpy::imports().glNormal3x(nx, ny, nz);
        GAPID_DEBUG("glNormal3x() -- done");
    }
}
EXPORT void STDCALL glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glNormal3xOES(%" PRId32 ", %" PRId32 ", %" PRId32 ")", nx, ny, nz);
    if (s->enter("glNormal3xOES")) {
        s->glNormal3xOES(nx, ny, nz);
        s->exit();
        GAPID_DEBUG("glNormal3xOES() -- done");
    } else {
        GAPID_INFO("glNormal3xOES at %p: GAPII re-entered. Just invoking imported function at %p", glNormal3xOES, s->GlesSpy::imports().glNormal3xOES);
        s->GlesSpy::imports().glNormal3xOES(nx, ny, nz);
        GAPID_DEBUG("glNormal3xOES() -- done");
    }
}
EXPORT void STDCALL glNormalPointer(uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glNormalPointer(%u, %" PRId32 ", %p)", type, stride, pointer);
    if (s->enter("glNormalPointer")) {
        s->glNormalPointer(type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glNormalPointer() -- done");
    } else {
        GAPID_INFO("glNormalPointer at %p: GAPII re-entered. Just invoking imported function at %p", glNormalPointer, s->GlesSpy::imports().glNormalPointer);
        s->GlesSpy::imports().glNormalPointer(type, stride, pointer);
        GAPID_DEBUG("glNormalPointer() -- done");
    }
}
EXPORT void STDCALL glOrthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glOrthof(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
    if (s->enter("glOrthof")) {
        s->glOrthof(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glOrthof() -- done");
    } else {
        GAPID_INFO("glOrthof at %p: GAPII re-entered. Just invoking imported function at %p", glOrthof, s->GlesSpy::imports().glOrthof);
        s->GlesSpy::imports().glOrthof(l, r, b, t, n, f);
        GAPID_DEBUG("glOrthof() -- done");
    }
}
EXPORT void STDCALL glOrthofOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glOrthofOES(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
    if (s->enter("glOrthofOES")) {
        s->glOrthofOES(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glOrthofOES() -- done");
    } else {
        GAPID_INFO("glOrthofOES at %p: GAPII re-entered. Just invoking imported function at %p", glOrthofOES, s->GlesSpy::imports().glOrthofOES);
        s->GlesSpy::imports().glOrthofOES(l, r, b, t, n, f);
        GAPID_DEBUG("glOrthofOES() -- done");
    }
}
EXPORT void STDCALL glOrthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glOrthox(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
    if (s->enter("glOrthox")) {
        s->glOrthox(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glOrthox() -- done");
    } else {
        GAPID_INFO("glOrthox at %p: GAPII re-entered. Just invoking imported function at %p", glOrthox, s->GlesSpy::imports().glOrthox);
        s->GlesSpy::imports().glOrthox(l, r, b, t, n, f);
        GAPID_DEBUG("glOrthox() -- done");
    }
}
EXPORT void STDCALL glOrthoxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glOrthoxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
    if (s->enter("glOrthoxOES")) {
        s->glOrthoxOES(l, r, b, t, n, f);
        s->exit();
        GAPID_DEBUG("glOrthoxOES() -- done");
    } else {
        GAPID_INFO("glOrthoxOES at %p: GAPII re-entered. Just invoking imported function at %p", glOrthoxOES, s->GlesSpy::imports().glOrthoxOES);
        s->GlesSpy::imports().glOrthoxOES(l, r, b, t, n, f);
        GAPID_DEBUG("glOrthoxOES() -- done");
    }
}
EXPORT void STDCALL glPointParameterf(uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointParameterf(%u, %f)", pname, param);
    if (s->enter("glPointParameterf")) {
        s->glPointParameterf(pname, param);
        s->exit();
        GAPID_DEBUG("glPointParameterf() -- done");
    } else {
        GAPID_INFO("glPointParameterf at %p: GAPII re-entered. Just invoking imported function at %p", glPointParameterf, s->GlesSpy::imports().glPointParameterf);
        s->GlesSpy::imports().glPointParameterf(pname, param);
        GAPID_DEBUG("glPointParameterf() -- done");
    }
}
EXPORT void STDCALL glPointParameterfv(uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointParameterfv(%u, %p)", pname, params);
    if (s->enter("glPointParameterfv")) {
        s->glPointParameterfv(pname, params);
        s->exit();
        GAPID_DEBUG("glPointParameterfv() -- done");
    } else {
        GAPID_INFO("glPointParameterfv at %p: GAPII re-entered. Just invoking imported function at %p", glPointParameterfv, s->GlesSpy::imports().glPointParameterfv);
        s->GlesSpy::imports().glPointParameterfv(pname, params);
        GAPID_DEBUG("glPointParameterfv() -- done");
    }
}
EXPORT void STDCALL glPointParameterx(uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointParameterx(%u, %" PRId32 ")", pname, param);
    if (s->enter("glPointParameterx")) {
        s->glPointParameterx(pname, param);
        s->exit();
        GAPID_DEBUG("glPointParameterx() -- done");
    } else {
        GAPID_INFO("glPointParameterx at %p: GAPII re-entered. Just invoking imported function at %p", glPointParameterx, s->GlesSpy::imports().glPointParameterx);
        s->GlesSpy::imports().glPointParameterx(pname, param);
        GAPID_DEBUG("glPointParameterx() -- done");
    }
}
EXPORT void STDCALL glPointParameterxOES(uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointParameterxOES(%u, %" PRId32 ")", pname, param);
    if (s->enter("glPointParameterxOES")) {
        s->glPointParameterxOES(pname, param);
        s->exit();
        GAPID_DEBUG("glPointParameterxOES() -- done");
    } else {
        GAPID_INFO("glPointParameterxOES at %p: GAPII re-entered. Just invoking imported function at %p", glPointParameterxOES, s->GlesSpy::imports().glPointParameterxOES);
        s->GlesSpy::imports().glPointParameterxOES(pname, param);
        GAPID_DEBUG("glPointParameterxOES() -- done");
    }
}
EXPORT void STDCALL glPointParameterxv(uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointParameterxv(%u, %p)", pname, params);
    if (s->enter("glPointParameterxv")) {
        s->glPointParameterxv(pname, params);
        s->exit();
        GAPID_DEBUG("glPointParameterxv() -- done");
    } else {
        GAPID_INFO("glPointParameterxv at %p: GAPII re-entered. Just invoking imported function at %p", glPointParameterxv, s->GlesSpy::imports().glPointParameterxv);
        s->GlesSpy::imports().glPointParameterxv(pname, params);
        GAPID_DEBUG("glPointParameterxv() -- done");
    }
}
EXPORT void STDCALL glPointParameterxvOES(uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointParameterxvOES(%u, %p)", pname, params);
    if (s->enter("glPointParameterxvOES")) {
        s->glPointParameterxvOES(pname, params);
        s->exit();
        GAPID_DEBUG("glPointParameterxvOES() -- done");
    } else {
        GAPID_INFO("glPointParameterxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glPointParameterxvOES, s->GlesSpy::imports().glPointParameterxvOES);
        s->GlesSpy::imports().glPointParameterxvOES(pname, params);
        GAPID_DEBUG("glPointParameterxvOES() -- done");
    }
}
EXPORT void STDCALL glPointSize(GLfloat size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSize(%f)", size);
    if (s->enter("glPointSize")) {
        s->glPointSize(size);
        s->exit();
        GAPID_DEBUG("glPointSize() -- done");
    } else {
        GAPID_INFO("glPointSize at %p: GAPII re-entered. Just invoking imported function at %p", glPointSize, s->GlesSpy::imports().glPointSize);
        s->GlesSpy::imports().glPointSize(size);
        GAPID_DEBUG("glPointSize() -- done");
    }
}
EXPORT void STDCALL glPointSizePointerOES(uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSizePointerOES(%u, %" PRId32 ", %p)", type, stride, pointer);
    if (s->enter("glPointSizePointerOES")) {
        s->glPointSizePointerOES(type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glPointSizePointerOES() -- done");
    } else {
        GAPID_INFO("glPointSizePointerOES at %p: GAPII re-entered. Just invoking imported function at %p", glPointSizePointerOES, s->GlesSpy::imports().glPointSizePointerOES);
        s->GlesSpy::imports().glPointSizePointerOES(type, stride, pointer);
        GAPID_DEBUG("glPointSizePointerOES() -- done");
    }
}
EXPORT void STDCALL glPointSizex(GLfixed size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSizex(%" PRId32 ")", size);
    if (s->enter("glPointSizex")) {
        s->glPointSizex(size);
        s->exit();
        GAPID_DEBUG("glPointSizex() -- done");
    } else {
        GAPID_INFO("glPointSizex at %p: GAPII re-entered. Just invoking imported function at %p", glPointSizex, s->GlesSpy::imports().glPointSizex);
        s->GlesSpy::imports().glPointSizex(size);
        GAPID_DEBUG("glPointSizex() -- done");
    }
}
EXPORT void STDCALL glPointSizexOES(GLfixed size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSizexOES(%" PRId32 ")", size);
    if (s->enter("glPointSizexOES")) {
        s->glPointSizexOES(size);
        s->exit();
        GAPID_DEBUG("glPointSizexOES() -- done");
    } else {
        GAPID_INFO("glPointSizexOES at %p: GAPII re-entered. Just invoking imported function at %p", glPointSizexOES, s->GlesSpy::imports().glPointSizexOES);
        s->GlesSpy::imports().glPointSizexOES(size);
        GAPID_DEBUG("glPointSizexOES() -- done");
    }
}
EXPORT void STDCALL glPolygonOffsetx(GLfixed factor, GLfixed units) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPolygonOffsetx(%" PRId32 ", %" PRId32 ")", factor, units);
    if (s->enter("glPolygonOffsetx")) {
        s->glPolygonOffsetx(factor, units);
        s->exit();
        GAPID_DEBUG("glPolygonOffsetx() -- done");
    } else {
        GAPID_INFO("glPolygonOffsetx at %p: GAPII re-entered. Just invoking imported function at %p", glPolygonOffsetx, s->GlesSpy::imports().glPolygonOffsetx);
        s->GlesSpy::imports().glPolygonOffsetx(factor, units);
        GAPID_DEBUG("glPolygonOffsetx() -- done");
    }
}
EXPORT void STDCALL glPolygonOffsetxOES(GLfixed factor, GLfixed units) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPolygonOffsetxOES(%" PRId32 ", %" PRId32 ")", factor, units);
    if (s->enter("glPolygonOffsetxOES")) {
        s->glPolygonOffsetxOES(factor, units);
        s->exit();
        GAPID_DEBUG("glPolygonOffsetxOES() -- done");
    } else {
        GAPID_INFO("glPolygonOffsetxOES at %p: GAPII re-entered. Just invoking imported function at %p", glPolygonOffsetxOES, s->GlesSpy::imports().glPolygonOffsetxOES);
        s->GlesSpy::imports().glPolygonOffsetxOES(factor, units);
        GAPID_DEBUG("glPolygonOffsetxOES() -- done");
    }
}
EXPORT void STDCALL glPopMatrix() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopMatrix()");
    if (s->enter("glPopMatrix")) {
        s->glPopMatrix();
        s->exit();
        GAPID_DEBUG("glPopMatrix() -- done");
    } else {
        GAPID_INFO("glPopMatrix at %p: GAPII re-entered. Just invoking imported function at %p", glPopMatrix, s->GlesSpy::imports().glPopMatrix);
        s->GlesSpy::imports().glPopMatrix();
        GAPID_DEBUG("glPopMatrix() -- done");
    }
}
EXPORT void STDCALL glPushMatrix() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPushMatrix()");
    if (s->enter("glPushMatrix")) {
        s->glPushMatrix();
        s->exit();
        GAPID_DEBUG("glPushMatrix() -- done");
    } else {
        GAPID_INFO("glPushMatrix at %p: GAPII re-entered. Just invoking imported function at %p", glPushMatrix, s->GlesSpy::imports().glPushMatrix);
        s->GlesSpy::imports().glPushMatrix();
        GAPID_DEBUG("glPushMatrix() -- done");
    }
}
EXPORT uint32_t STDCALL glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glQueryMatrixxOES(%p, %p)", mantissa, exponent);
    if (s->enter("glQueryMatrixxOES")) {
        auto _result_ = s->glQueryMatrixxOES(mantissa, exponent);
        s->exit();
        GAPID_DEBUG("glQueryMatrixxOES() -- done");
        return _result_;
    } else {
        GAPID_INFO("glQueryMatrixxOES at %p: GAPII re-entered. Just invoking imported function at %p", glQueryMatrixxOES, s->GlesSpy::imports().glQueryMatrixxOES);
        auto _result_ = s->GlesSpy::imports().glQueryMatrixxOES(mantissa, exponent);
        GAPID_DEBUG("glQueryMatrixxOES() -- done");
        return _result_;
    }
}
EXPORT void STDCALL glRenderbufferStorageOES(uint32_t target, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRenderbufferStorageOES(%u, %u, %" PRId32 ", %" PRId32 ")", target, internalformat, width, height);
    if (s->enter("glRenderbufferStorageOES")) {
        s->glRenderbufferStorageOES(target, internalformat, width, height);
        s->exit();
        GAPID_DEBUG("glRenderbufferStorageOES() -- done");
    } else {
        GAPID_INFO("glRenderbufferStorageOES at %p: GAPII re-entered. Just invoking imported function at %p", glRenderbufferStorageOES, s->GlesSpy::imports().glRenderbufferStorageOES);
        s->GlesSpy::imports().glRenderbufferStorageOES(target, internalformat, width, height);
        GAPID_DEBUG("glRenderbufferStorageOES() -- done");
    }
}
EXPORT void STDCALL glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRotatef(%f, %f, %f, %f)", angle, x, y, z);
    if (s->enter("glRotatef")) {
        s->glRotatef(angle, x, y, z);
        s->exit();
        GAPID_DEBUG("glRotatef() -- done");
    } else {
        GAPID_INFO("glRotatef at %p: GAPII re-entered. Just invoking imported function at %p", glRotatef, s->GlesSpy::imports().glRotatef);
        s->GlesSpy::imports().glRotatef(angle, x, y, z);
        GAPID_DEBUG("glRotatef() -- done");
    }
}
EXPORT void STDCALL glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRotatex(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", angle, x, y, z);
    if (s->enter("glRotatex")) {
        s->glRotatex(angle, x, y, z);
        s->exit();
        GAPID_DEBUG("glRotatex() -- done");
    } else {
        GAPID_INFO("glRotatex at %p: GAPII re-entered. Just invoking imported function at %p", glRotatex, s->GlesSpy::imports().glRotatex);
        s->GlesSpy::imports().glRotatex(angle, x, y, z);
        GAPID_DEBUG("glRotatex() -- done");
    }
}
EXPORT void STDCALL glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glRotatexOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", angle, x, y, z);
    if (s->enter("glRotatexOES")) {
        s->glRotatexOES(angle, x, y, z);
        s->exit();
        GAPID_DEBUG("glRotatexOES() -- done");
    } else {
        GAPID_INFO("glRotatexOES at %p: GAPII re-entered. Just invoking imported function at %p", glRotatexOES, s->GlesSpy::imports().glRotatexOES);
        s->GlesSpy::imports().glRotatexOES(angle, x, y, z);
        GAPID_DEBUG("glRotatexOES() -- done");
    }
}
EXPORT void STDCALL glSampleCoveragex(GLclampx value, GLboolean invert) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSampleCoveragex(%" PRId32 ", %" PRIu8 ")", value, invert);
    if (s->enter("glSampleCoveragex")) {
        s->glSampleCoveragex(value, invert);
        s->exit();
        GAPID_DEBUG("glSampleCoveragex() -- done");
    } else {
        GAPID_INFO("glSampleCoveragex at %p: GAPII re-entered. Just invoking imported function at %p", glSampleCoveragex, s->GlesSpy::imports().glSampleCoveragex);
        s->GlesSpy::imports().glSampleCoveragex(value, invert);
        GAPID_DEBUG("glSampleCoveragex() -- done");
    }
}
EXPORT void STDCALL glSampleCoveragexOES(GLclampx value, GLboolean invert) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glSampleCoveragexOES(%" PRId32 ", %" PRIu8 ")", value, invert);
    if (s->enter("glSampleCoveragexOES")) {
        s->glSampleCoveragexOES(value, invert);
        s->exit();
        GAPID_DEBUG("glSampleCoveragexOES() -- done");
    } else {
        GAPID_INFO("glSampleCoveragexOES at %p: GAPII re-entered. Just invoking imported function at %p", glSampleCoveragexOES, s->GlesSpy::imports().glSampleCoveragexOES);
        s->GlesSpy::imports().glSampleCoveragexOES(value, invert);
        GAPID_DEBUG("glSampleCoveragexOES() -- done");
    }
}
EXPORT void STDCALL glScalef(GLfloat x, GLfloat y, GLfloat z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScalef(%f, %f, %f)", x, y, z);
    if (s->enter("glScalef")) {
        s->glScalef(x, y, z);
        s->exit();
        GAPID_DEBUG("glScalef() -- done");
    } else {
        GAPID_INFO("glScalef at %p: GAPII re-entered. Just invoking imported function at %p", glScalef, s->GlesSpy::imports().glScalef);
        s->GlesSpy::imports().glScalef(x, y, z);
        GAPID_DEBUG("glScalef() -- done");
    }
}
EXPORT void STDCALL glScalex(GLfixed x, GLfixed y, GLfixed z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScalex(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
    if (s->enter("glScalex")) {
        s->glScalex(x, y, z);
        s->exit();
        GAPID_DEBUG("glScalex() -- done");
    } else {
        GAPID_INFO("glScalex at %p: GAPII re-entered. Just invoking imported function at %p", glScalex, s->GlesSpy::imports().glScalex);
        s->GlesSpy::imports().glScalex(x, y, z);
        GAPID_DEBUG("glScalex() -- done");
    }
}
EXPORT void STDCALL glScalexOES(GLfixed x, GLfixed y, GLfixed z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScalexOES(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
    if (s->enter("glScalexOES")) {
        s->glScalexOES(x, y, z);
        s->exit();
        GAPID_DEBUG("glScalexOES() -- done");
    } else {
        GAPID_INFO("glScalexOES at %p: GAPII re-entered. Just invoking imported function at %p", glScalexOES, s->GlesSpy::imports().glScalexOES);
        s->GlesSpy::imports().glScalexOES(x, y, z);
        GAPID_DEBUG("glScalexOES() -- done");
    }
}
EXPORT void STDCALL glShadeModel(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glShadeModel(%u)", mode);
    if (s->enter("glShadeModel")) {
        s->glShadeModel(mode);
        s->exit();
        GAPID_DEBUG("glShadeModel() -- done");
    } else {
        GAPID_INFO("glShadeModel at %p: GAPII re-entered. Just invoking imported function at %p", glShadeModel, s->GlesSpy::imports().glShadeModel);
        s->GlesSpy::imports().glShadeModel(mode);
        GAPID_DEBUG("glShadeModel() -- done");
    }
}
EXPORT void STDCALL glTexCoordPointer(GLint size, uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexCoordPointer(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
    if (s->enter("glTexCoordPointer")) {
        s->glTexCoordPointer(size, type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glTexCoordPointer() -- done");
    } else {
        GAPID_INFO("glTexCoordPointer at %p: GAPII re-entered. Just invoking imported function at %p", glTexCoordPointer, s->GlesSpy::imports().glTexCoordPointer);
        s->GlesSpy::imports().glTexCoordPointer(size, type, stride, pointer);
        GAPID_DEBUG("glTexCoordPointer() -- done");
    }
}
EXPORT void STDCALL glTexEnvf(uint32_t target, uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvf(%u, %u, %f)", target, pname, param);
    if (s->enter("glTexEnvf")) {
        s->glTexEnvf(target, pname, param);
        s->exit();
        GAPID_DEBUG("glTexEnvf() -- done");
    } else {
        GAPID_INFO("glTexEnvf at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvf, s->GlesSpy::imports().glTexEnvf);
        s->GlesSpy::imports().glTexEnvf(target, pname, param);
        GAPID_DEBUG("glTexEnvf() -- done");
    }
}
EXPORT void STDCALL glTexEnvfv(uint32_t target, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvfv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexEnvfv")) {
        s->glTexEnvfv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexEnvfv() -- done");
    } else {
        GAPID_INFO("glTexEnvfv at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvfv, s->GlesSpy::imports().glTexEnvfv);
        s->GlesSpy::imports().glTexEnvfv(target, pname, params);
        GAPID_DEBUG("glTexEnvfv() -- done");
    }
}
EXPORT void STDCALL glTexEnvi(uint32_t target, uint32_t pname, GLint param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvi(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glTexEnvi")) {
        s->glTexEnvi(target, pname, param);
        s->exit();
        GAPID_DEBUG("glTexEnvi() -- done");
    } else {
        GAPID_INFO("glTexEnvi at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvi, s->GlesSpy::imports().glTexEnvi);
        s->GlesSpy::imports().glTexEnvi(target, pname, param);
        GAPID_DEBUG("glTexEnvi() -- done");
    }
}
EXPORT void STDCALL glTexEnviv(uint32_t target, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnviv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexEnviv")) {
        s->glTexEnviv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexEnviv() -- done");
    } else {
        GAPID_INFO("glTexEnviv at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnviv, s->GlesSpy::imports().glTexEnviv);
        s->GlesSpy::imports().glTexEnviv(target, pname, params);
        GAPID_DEBUG("glTexEnviv() -- done");
    }
}
EXPORT void STDCALL glTexEnvx(uint32_t target, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvx(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glTexEnvx")) {
        s->glTexEnvx(target, pname, param);
        s->exit();
        GAPID_DEBUG("glTexEnvx() -- done");
    } else {
        GAPID_INFO("glTexEnvx at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvx, s->GlesSpy::imports().glTexEnvx);
        s->GlesSpy::imports().glTexEnvx(target, pname, param);
        GAPID_DEBUG("glTexEnvx() -- done");
    }
}
EXPORT void STDCALL glTexEnvxOES(uint32_t target, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvxOES(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glTexEnvxOES")) {
        s->glTexEnvxOES(target, pname, param);
        s->exit();
        GAPID_DEBUG("glTexEnvxOES() -- done");
    } else {
        GAPID_INFO("glTexEnvxOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvxOES, s->GlesSpy::imports().glTexEnvxOES);
        s->GlesSpy::imports().glTexEnvxOES(target, pname, param);
        GAPID_DEBUG("glTexEnvxOES() -- done");
    }
}
EXPORT void STDCALL glTexEnvxv(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvxv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexEnvxv")) {
        s->glTexEnvxv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexEnvxv() -- done");
    } else {
        GAPID_INFO("glTexEnvxv at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvxv, s->GlesSpy::imports().glTexEnvxv);
        s->GlesSpy::imports().glTexEnvxv(target, pname, params);
        GAPID_DEBUG("glTexEnvxv() -- done");
    }
}
EXPORT void STDCALL glTexEnvxvOES(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexEnvxvOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexEnvxvOES")) {
        s->glTexEnvxvOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexEnvxvOES() -- done");
    } else {
        GAPID_INFO("glTexEnvxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexEnvxvOES, s->GlesSpy::imports().glTexEnvxvOES);
        s->GlesSpy::imports().glTexEnvxvOES(target, pname, params);
        GAPID_DEBUG("glTexEnvxvOES() -- done");
    }
}
EXPORT void STDCALL glTexGenfOES(uint32_t coord, uint32_t pname, GLfloat param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexGenfOES(%u, %u, %f)", coord, pname, param);
    if (s->enter("glTexGenfOES")) {
        s->glTexGenfOES(coord, pname, param);
        s->exit();
        GAPID_DEBUG("glTexGenfOES() -- done");
    } else {
        GAPID_INFO("glTexGenfOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexGenfOES, s->GlesSpy::imports().glTexGenfOES);
        s->GlesSpy::imports().glTexGenfOES(coord, pname, param);
        GAPID_DEBUG("glTexGenfOES() -- done");
    }
}
EXPORT void STDCALL glTexGenfvOES(uint32_t coord, uint32_t pname, GLfloat* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexGenfvOES(%u, %u, %p)", coord, pname, params);
    if (s->enter("glTexGenfvOES")) {
        s->glTexGenfvOES(coord, pname, params);
        s->exit();
        GAPID_DEBUG("glTexGenfvOES() -- done");
    } else {
        GAPID_INFO("glTexGenfvOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexGenfvOES, s->GlesSpy::imports().glTexGenfvOES);
        s->GlesSpy::imports().glTexGenfvOES(coord, pname, params);
        GAPID_DEBUG("glTexGenfvOES() -- done");
    }
}
EXPORT void STDCALL glTexGeniOES(uint32_t coord, uint32_t pname, GLint param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexGeniOES(%u, %u, %" PRId32 ")", coord, pname, param);
    if (s->enter("glTexGeniOES")) {
        s->glTexGeniOES(coord, pname, param);
        s->exit();
        GAPID_DEBUG("glTexGeniOES() -- done");
    } else {
        GAPID_INFO("glTexGeniOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexGeniOES, s->GlesSpy::imports().glTexGeniOES);
        s->GlesSpy::imports().glTexGeniOES(coord, pname, param);
        GAPID_DEBUG("glTexGeniOES() -- done");
    }
}
EXPORT void STDCALL glTexGenivOES(uint32_t coord, uint32_t pname, GLint* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexGenivOES(%u, %u, %p)", coord, pname, params);
    if (s->enter("glTexGenivOES")) {
        s->glTexGenivOES(coord, pname, params);
        s->exit();
        GAPID_DEBUG("glTexGenivOES() -- done");
    } else {
        GAPID_INFO("glTexGenivOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexGenivOES, s->GlesSpy::imports().glTexGenivOES);
        s->GlesSpy::imports().glTexGenivOES(coord, pname, params);
        GAPID_DEBUG("glTexGenivOES() -- done");
    }
}
EXPORT void STDCALL glTexGenxOES(uint32_t coord, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexGenxOES(%u, %u, %" PRId32 ")", coord, pname, param);
    if (s->enter("glTexGenxOES")) {
        s->glTexGenxOES(coord, pname, param);
        s->exit();
        GAPID_DEBUG("glTexGenxOES() -- done");
    } else {
        GAPID_INFO("glTexGenxOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexGenxOES, s->GlesSpy::imports().glTexGenxOES);
        s->GlesSpy::imports().glTexGenxOES(coord, pname, param);
        GAPID_DEBUG("glTexGenxOES() -- done");
    }
}
EXPORT void STDCALL glTexGenxvOES(uint32_t coord, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexGenxvOES(%u, %u, %p)", coord, pname, params);
    if (s->enter("glTexGenxvOES")) {
        s->glTexGenxvOES(coord, pname, params);
        s->exit();
        GAPID_DEBUG("glTexGenxvOES() -- done");
    } else {
        GAPID_INFO("glTexGenxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexGenxvOES, s->GlesSpy::imports().glTexGenxvOES);
        s->GlesSpy::imports().glTexGenxvOES(coord, pname, params);
        GAPID_DEBUG("glTexGenxvOES() -- done");
    }
}
EXPORT void STDCALL glTexParameterx(uint32_t target, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterx(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glTexParameterx")) {
        s->glTexParameterx(target, pname, param);
        s->exit();
        GAPID_DEBUG("glTexParameterx() -- done");
    } else {
        GAPID_INFO("glTexParameterx at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterx, s->GlesSpy::imports().glTexParameterx);
        s->GlesSpy::imports().glTexParameterx(target, pname, param);
        GAPID_DEBUG("glTexParameterx() -- done");
    }
}
EXPORT void STDCALL glTexParameterxOES(uint32_t target, uint32_t pname, GLfixed param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterxOES(%u, %u, %" PRId32 ")", target, pname, param);
    if (s->enter("glTexParameterxOES")) {
        s->glTexParameterxOES(target, pname, param);
        s->exit();
        GAPID_DEBUG("glTexParameterxOES() -- done");
    } else {
        GAPID_INFO("glTexParameterxOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterxOES, s->GlesSpy::imports().glTexParameterxOES);
        s->GlesSpy::imports().glTexParameterxOES(target, pname, param);
        GAPID_DEBUG("glTexParameterxOES() -- done");
    }
}
EXPORT void STDCALL glTexParameterxv(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterxv(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterxv")) {
        s->glTexParameterxv(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterxv() -- done");
    } else {
        GAPID_INFO("glTexParameterxv at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterxv, s->GlesSpy::imports().glTexParameterxv);
        s->GlesSpy::imports().glTexParameterxv(target, pname, params);
        GAPID_DEBUG("glTexParameterxv() -- done");
    }
}
EXPORT void STDCALL glTexParameterxvOES(uint32_t target, uint32_t pname, GLfixed* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexParameterxvOES(%u, %u, %p)", target, pname, params);
    if (s->enter("glTexParameterxvOES")) {
        s->glTexParameterxvOES(target, pname, params);
        s->exit();
        GAPID_DEBUG("glTexParameterxvOES() -- done");
    } else {
        GAPID_INFO("glTexParameterxvOES at %p: GAPII re-entered. Just invoking imported function at %p", glTexParameterxvOES, s->GlesSpy::imports().glTexParameterxvOES);
        s->GlesSpy::imports().glTexParameterxvOES(target, pname, params);
        GAPID_DEBUG("glTexParameterxvOES() -- done");
    }
}
EXPORT void STDCALL glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTranslatef(%f, %f, %f)", x, y, z);
    if (s->enter("glTranslatef")) {
        s->glTranslatef(x, y, z);
        s->exit();
        GAPID_DEBUG("glTranslatef() -- done");
    } else {
        GAPID_INFO("glTranslatef at %p: GAPII re-entered. Just invoking imported function at %p", glTranslatef, s->GlesSpy::imports().glTranslatef);
        s->GlesSpy::imports().glTranslatef(x, y, z);
        GAPID_DEBUG("glTranslatef() -- done");
    }
}
EXPORT void STDCALL glTranslatex(GLfixed x, GLfixed y, GLfixed z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTranslatex(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
    if (s->enter("glTranslatex")) {
        s->glTranslatex(x, y, z);
        s->exit();
        GAPID_DEBUG("glTranslatex() -- done");
    } else {
        GAPID_INFO("glTranslatex at %p: GAPII re-entered. Just invoking imported function at %p", glTranslatex, s->GlesSpy::imports().glTranslatex);
        s->GlesSpy::imports().glTranslatex(x, y, z);
        GAPID_DEBUG("glTranslatex() -- done");
    }
}
EXPORT void STDCALL glTranslatexOES(GLfixed x, GLfixed y, GLfixed z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTranslatexOES(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
    if (s->enter("glTranslatexOES")) {
        s->glTranslatexOES(x, y, z);
        s->exit();
        GAPID_DEBUG("glTranslatexOES() -- done");
    } else {
        GAPID_INFO("glTranslatexOES at %p: GAPII re-entered. Just invoking imported function at %p", glTranslatexOES, s->GlesSpy::imports().glTranslatexOES);
        s->GlesSpy::imports().glTranslatexOES(x, y, z);
        GAPID_DEBUG("glTranslatexOES() -- done");
    }
}
EXPORT void STDCALL glVertexPointer(GLint size, uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexPointer(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
    if (s->enter("glVertexPointer")) {
        s->glVertexPointer(size, type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glVertexPointer() -- done");
    } else {
        GAPID_INFO("glVertexPointer at %p: GAPII re-entered. Just invoking imported function at %p", glVertexPointer, s->GlesSpy::imports().glVertexPointer);
        s->GlesSpy::imports().glVertexPointer(size, type, stride, pointer);
        GAPID_DEBUG("glVertexPointer() -- done");
    }
}
EXPORT void STDCALL glWeightPointerOES(GLint size, uint32_t type, GLsizei stride, void* pointer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glWeightPointerOES(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
    if (s->enter("glWeightPointerOES")) {
        s->glWeightPointerOES(size, type, stride, pointer);
        s->exit();
        GAPID_DEBUG("glWeightPointerOES() -- done");
    } else {
        GAPID_INFO("glWeightPointerOES at %p: GAPII re-entered. Just invoking imported function at %p", glWeightPointerOES, s->GlesSpy::imports().glWeightPointerOES);
        s->GlesSpy::imports().glWeightPointerOES(size, type, stride, pointer);
        GAPID_DEBUG("glWeightPointerOES() -- done");
    }
}
EXPORT void STDCALL glColorPointerBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glColorPointerBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
    if (s->enter("glColorPointerBounds")) {
        s->glColorPointerBounds(size, type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glColorPointerBounds() -- done");
    } else {
        GAPID_INFO("glColorPointerBounds at %p: GAPII re-entered. Just invoking imported function at %p", glColorPointerBounds, s->GlesSpy::imports().glColorPointerBounds);
        s->GlesSpy::imports().glColorPointerBounds(size, type, stride, pointer, count);
        GAPID_DEBUG("glColorPointerBounds() -- done");
    }
}
EXPORT void STDCALL glNormalPointerBounds(uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glNormalPointerBounds(%u, %" PRId32 ", %p, %" PRId32 ")", type, stride, pointer, count);
    if (s->enter("glNormalPointerBounds")) {
        s->glNormalPointerBounds(type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glNormalPointerBounds() -- done");
    } else {
        GAPID_INFO("glNormalPointerBounds at %p: GAPII re-entered. Just invoking imported function at %p", glNormalPointerBounds, s->GlesSpy::imports().glNormalPointerBounds);
        s->GlesSpy::imports().glNormalPointerBounds(type, stride, pointer, count);
        GAPID_DEBUG("glNormalPointerBounds() -- done");
    }
}
EXPORT void STDCALL glTexCoordPointerBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexCoordPointerBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
    if (s->enter("glTexCoordPointerBounds")) {
        s->glTexCoordPointerBounds(size, type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glTexCoordPointerBounds() -- done");
    } else {
        GAPID_INFO("glTexCoordPointerBounds at %p: GAPII re-entered. Just invoking imported function at %p", glTexCoordPointerBounds, s->GlesSpy::imports().glTexCoordPointerBounds);
        s->GlesSpy::imports().glTexCoordPointerBounds(size, type, stride, pointer, count);
        GAPID_DEBUG("glTexCoordPointerBounds() -- done");
    }
}
EXPORT void STDCALL glVertexPointerBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glVertexPointerBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
    if (s->enter("glVertexPointerBounds")) {
        s->glVertexPointerBounds(size, type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glVertexPointerBounds() -- done");
    } else {
        GAPID_INFO("glVertexPointerBounds at %p: GAPII re-entered. Just invoking imported function at %p", glVertexPointerBounds, s->GlesSpy::imports().glVertexPointerBounds);
        s->GlesSpy::imports().glVertexPointerBounds(size, type, stride, pointer, count);
        GAPID_DEBUG("glVertexPointerBounds() -- done");
    }
}
EXPORT void STDCALL glPointSizePointerOESBounds(uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSizePointerOESBounds(%u, %" PRId32 ", %p, %" PRId32 ")", type, stride, pointer, count);
    if (s->enter("glPointSizePointerOESBounds")) {
        s->glPointSizePointerOESBounds(type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glPointSizePointerOESBounds() -- done");
    } else {
        GAPID_INFO("glPointSizePointerOESBounds at %p: GAPII re-entered. Just invoking imported function at %p", glPointSizePointerOESBounds, s->GlesSpy::imports().glPointSizePointerOESBounds);
        s->GlesSpy::imports().glPointSizePointerOESBounds(type, stride, pointer, count);
        GAPID_DEBUG("glPointSizePointerOESBounds() -- done");
    }
}
EXPORT void STDCALL glMatrixIndexPointerOESBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixIndexPointerOESBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
    if (s->enter("glMatrixIndexPointerOESBounds")) {
        s->glMatrixIndexPointerOESBounds(size, type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glMatrixIndexPointerOESBounds() -- done");
    } else {
        GAPID_INFO("glMatrixIndexPointerOESBounds at %p: GAPII re-entered. Just invoking imported function at %p", glMatrixIndexPointerOESBounds, s->GlesSpy::imports().glMatrixIndexPointerOESBounds);
        s->GlesSpy::imports().glMatrixIndexPointerOESBounds(size, type, stride, pointer, count);
        GAPID_DEBUG("glMatrixIndexPointerOESBounds() -- done");
    }
}
EXPORT void STDCALL glWeightPointerOESBounds(GLint size, uint32_t type, GLsizei stride, void* pointer, GLsizei count) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glWeightPointerOESBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
    if (s->enter("glWeightPointerOESBounds")) {
        s->glWeightPointerOESBounds(size, type, stride, pointer, count);
        s->exit();
        GAPID_DEBUG("glWeightPointerOESBounds() -- done");
    } else {
        GAPID_INFO("glWeightPointerOESBounds at %p: GAPII re-entered. Just invoking imported function at %p", glWeightPointerOESBounds, s->GlesSpy::imports().glWeightPointerOESBounds);
        s->GlesSpy::imports().glWeightPointerOESBounds(size, type, stride, pointer, count);
        GAPID_DEBUG("glWeightPointerOESBounds() -- done");
    }
}

EXPORT void* STDCALL eglGetProcAddress(const char* name)    { return GetSpyProcAddress(name); }
EXPORT void* STDCALL wglGetProcAddress(const char* name)    { return GetSpyProcAddress(name); }
EXPORT void* STDCALL glXGetProcAddress(const char* name)    { return GetSpyProcAddress(name); }
EXPORT void* STDCALL glXGetProcAddressARB(const char* name) { return GetSpyProcAddress(name); }

} // extern "C"