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_gles_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 glMapBuffer(uint32_t target, uint32_t access);
EXPORT void* STDCALL glMapBufferRange(uint32_t target, GLintptr offset, GLsizeiptr length, uint32_t access);
EXPORT GLboolean STDCALL glUnmapBuffer(uint32_t target);
EXPORT void STDCALL glFlushMappedBufferRange(uint32_t target, GLintptr offset, GLsizeiptr length);
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 EGLBoolean STDCALL eglGetConfigAttrib(EGLDisplay display, EGLConfig config, EGLint attribute, EGLint* value);
EXPORT EGLBoolean STDCALL eglBindAPI(uint32_t api);
EXPORT EGLBoolean STDCALL eglBindTexImage(EGLDisplay display, EGLSurface surface, EGLint buffer);
EXPORT EGLBoolean STDCALL eglChooseConfig(EGLDisplay display, EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
EXPORT EGLint STDCALL eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint sync_flags, EGLTimeKHR timeout);
EXPORT EGLBoolean STDCALL eglCopyBuffers(EGLDisplay display, EGLSurface surface, EGLNativePixmapType native_pixmap);
EXPORT EGLContext STDCALL eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, EGLint* attrib_list);
EXPORT EGLSurface STDCALL eglCreatePbufferFromClientBuffer(EGLDisplay display, uint32_t buftype, EGLClientBuffer buffer, EGLConfig config, EGLint* attrib_list);
EXPORT EGLSurface STDCALL eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, EGLint* attrib_list);
EXPORT EGLSurface STDCALL eglCreatePixmapSurface(EGLDisplay display, EGLConfig config, EGLNativePixmapType native_pixmap, EGLint* attrib_list);
EXPORT EGLSyncKHR STDCALL eglCreateSyncKHR(EGLDisplay dpy, uint32_t type, EGLint* attrib_list);
EXPORT EGLSurface STDCALL eglCreateWindowSurface(EGLDisplay display, EGLConfig config, EGLNativeWindowType native_window, EGLint* attrib_list);
EXPORT EGLBoolean STDCALL eglDestroyContext(EGLDisplay display, EGLContext context);
EXPORT EGLBoolean STDCALL eglDestroySurface(EGLDisplay display, EGLSurface surface);
EXPORT EGLBoolean STDCALL eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
EXPORT EGLBoolean STDCALL eglGetConfigs(EGLDisplay display, EGLConfig* configs, EGLint config_size, EGLint* num_config);
EXPORT EGLContext STDCALL eglGetCurrentContext();
EXPORT EGLDisplay STDCALL eglGetCurrentDisplay();
EXPORT EGLSurface STDCALL eglGetCurrentSurface(EGLint readdraw);
EXPORT EGLDisplay STDCALL eglGetDisplay(EGLNativeDisplayType native_display);
EXPORT EGLint STDCALL eglGetError();
EXPORT EGLBoolean STDCALL eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value);
EXPORT EGLBoolean STDCALL eglInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor);
EXPORT EGLBoolean STDCALL eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);
EXPORT uint32_t STDCALL eglQueryAPI();
EXPORT EGLBoolean STDCALL eglQueryContext(EGLDisplay display, EGLContext context, EGLint attribute, EGLint* value);
EXPORT EGLBoolean STDCALL eglQuerySurface(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint* value);
EXPORT char* STDCALL eglQueryString(EGLDisplay display, EGLint name);
EXPORT EGLBoolean STDCALL eglReleaseTexImage(EGLDisplay display, EGLSurface surface, EGLint buffer);
EXPORT EGLBoolean STDCALL eglReleaseThread();
EXPORT EGLBoolean STDCALL eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, uint32_t mode);
EXPORT EGLBoolean STDCALL eglSurfaceAttrib(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint value);
EXPORT EGLBoolean STDCALL eglSwapBuffers(EGLDisplay display, void* surface);
EXPORT EGLBoolean STDCALL eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface, EGLint* rects, EGLint n_rects);
EXPORT EGLBoolean STDCALL eglSwapInterval(EGLDisplay display, EGLint interval);
EXPORT EGLBoolean STDCALL eglTerminate(EGLDisplay display);
EXPORT EGLBoolean STDCALL eglWaitClient();
EXPORT EGLBoolean STDCALL eglWaitGL();
EXPORT EGLBoolean STDCALL eglWaitNative(EGLint engine);
EXPORT EGLImageKHR STDCALL eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, uint32_t target, EGLClientBuffer buffer, EGLint* attrib_list);
EXPORT EGLBoolean STDCALL eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image);
EXPORT EGLClientBuffer STDCALL eglCreateNativeClientBufferANDROID(EGLint* attrib_list);
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 internalformat, GLsizei width);
EXPORT void STDCALL glTexStorage2DEXT(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glTexStorage3DEXT(uint32_t target, GLsizei levels, uint32_t internalformat, 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 internalformat, GLsizei width);
EXPORT void STDCALL glTextureStorage2DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height);
EXPORT void STDCALL glTextureStorage3DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t internalformat, 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 glClearPixelLocalStorageuiEXT(GLsizei offset, GLsizei n, GLuint* values);
EXPORT void STDCALL glClearTexImageEXT(GLuint texture, GLint level, uint32_t format, uint32_t type, void* data);
EXPORT void STDCALL glClearTexSubImageEXT(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, void* data);
EXPORT void STDCALL glConservativeRasterParameteriNV(uint32_t pname, GLint param);
EXPORT void STDCALL glDepthRangeArrayfvOES(GLuint first, GLsizei count, GLfloat* v);
EXPORT void STDCALL glDepthRangeIndexedfOES(GLuint index, GLfloat n, GLfloat f);
EXPORT void STDCALL glDrawTransformFeedbackEXT(uint32_t mode, GLuint id);
EXPORT void STDCALL glDrawTransformFeedbackInstancedEXT(uint32_t mode, GLuint id, GLsizei instancecount);
EXPORT void STDCALL glFramebufferPixelLocalStorageSizeEXT(GLuint target, GLsizei size);
EXPORT void STDCALL glFramebufferTexture2DDownsampleIMG(uint32_t target, uint32_t attachment, uint32_t textarget, GLuint texture, GLint level, GLint xscale, GLint yscale);
EXPORT void STDCALL glFramebufferTextureLayerDownsampleIMG(uint32_t target, uint32_t attachment, GLuint texture, GLint level, GLint layer, GLint xscale, GLint yscale);
EXPORT void STDCALL glFramebufferTextureMultisampleMultiviewOVR(uint32_t target, uint32_t attachment, GLuint texture, GLint level, GLsizei samples, GLint baseViewIndex, GLsizei numViews);
EXPORT void STDCALL glGetFloati_vOES(uint32_t target, GLuint index, GLfloat* data);
EXPORT GLsizei STDCALL glGetFramebufferPixelLocalStorageSizeEXT(GLuint target);
EXPORT GLuint64 STDCALL glGetTextureHandleIMG(GLuint texture);
EXPORT GLuint64 STDCALL glGetTextureSamplerHandleIMG(GLuint texture, GLuint sampler);
EXPORT void STDCALL glGetUniformi64vNV(GLuint program, GLint location, GLint64EXT* params);
EXPORT void STDCALL glPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp);
EXPORT void STDCALL glProgramUniform1i64NV(GLuint program, GLint location, GLint64EXT x);
EXPORT void STDCALL glProgramUniform1i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glProgramUniform1ui64NV(GLuint program, GLint location, GLuint64EXT x);
EXPORT void STDCALL glProgramUniform1ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glProgramUniform2i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y);
EXPORT void STDCALL glProgramUniform2i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glProgramUniform2ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y);
EXPORT void STDCALL glProgramUniform2ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glProgramUniform3i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
EXPORT void STDCALL glProgramUniform3i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glProgramUniform3ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
EXPORT void STDCALL glProgramUniform3ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glProgramUniform4i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
EXPORT void STDCALL glProgramUniform4i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glProgramUniform4ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
EXPORT void STDCALL glProgramUniform4ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glProgramUniformHandleui64IMG(GLuint program, GLint location, GLuint64 value);
EXPORT void STDCALL glProgramUniformHandleui64vIMG(GLuint program, GLint location, GLsizei count, GLuint64* values);
EXPORT void STDCALL glScissorArrayvOES(GLuint first, GLsizei count, GLint* v);
EXPORT void STDCALL glScissorIndexedOES(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
EXPORT void STDCALL glScissorIndexedvOES(GLuint index, GLint* v);
EXPORT void STDCALL glUniform1i64NV(GLint location, GLint64EXT x);
EXPORT void STDCALL glUniform1i64vNV(GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glUniform1ui64NV(GLint location, GLuint64EXT x);
EXPORT void STDCALL glUniform1ui64vNV(GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glUniform2i64NV(GLint location, GLint64EXT x, GLint64EXT y);
EXPORT void STDCALL glUniform2i64vNV(GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glUniform2ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y);
EXPORT void STDCALL glUniform2ui64vNV(GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glUniform3i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z);
EXPORT void STDCALL glUniform3i64vNV(GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glUniform3ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z);
EXPORT void STDCALL glUniform3ui64vNV(GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glUniform4i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w);
EXPORT void STDCALL glUniform4i64vNV(GLint location, GLsizei count, GLint64EXT* value);
EXPORT void STDCALL glUniform4ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w);
EXPORT void STDCALL glUniform4ui64vNV(GLint location, GLsizei count, GLuint64EXT* value);
EXPORT void STDCALL glUniformHandleui64IMG(GLint location, GLuint64 value);
EXPORT void STDCALL glUniformHandleui64vIMG(GLint location, GLsizei count, GLuint64* value);
EXPORT void STDCALL glViewportArrayvOES(GLuint first, GLsizei count, GLfloat* v);
EXPORT void STDCALL glViewportIndexedfOES(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
EXPORT void STDCALL glViewportIndexedfvOES(GLuint index, GLfloat* v);
EXPORT void STDCALL glViewportSwizzleNV(GLuint index, uint32_t swizzlex, uint32_t swizzley, uint32_t swizzlez, uint32_t swizzlew);
EXPORT void STDCALL glWindowRectanglesEXT(uint32_t mode, GLsizei count, GLint* box);
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 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 internalformat, 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 internalformat, 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 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 glTexStorage1D(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width);
EXPORT void STDCALL glBindFragDataLocation(ProgramId program, GLuint color, const char* name);
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)},
        {"glMapBuffer", reinterpret_cast<void*>(glMapBuffer)},
        {"glMapBufferRange", reinterpret_cast<void*>(glMapBufferRange)},
        {"glUnmapBuffer", reinterpret_cast<void*>(glUnmapBuffer)},
        {"glFlushMappedBufferRange", reinterpret_cast<void*>(glFlushMappedBufferRange)},
        {"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)},
        {"eglGetConfigAttrib", reinterpret_cast<void*>(eglGetConfigAttrib)},
        {"eglBindAPI", reinterpret_cast<void*>(eglBindAPI)},
        {"eglBindTexImage", reinterpret_cast<void*>(eglBindTexImage)},
        {"eglChooseConfig", reinterpret_cast<void*>(eglChooseConfig)},
        {"eglClientWaitSyncKHR", reinterpret_cast<void*>(eglClientWaitSyncKHR)},
        {"eglCopyBuffers", reinterpret_cast<void*>(eglCopyBuffers)},
        {"eglCreateContext", reinterpret_cast<void*>(eglCreateContext)},
        {"eglCreatePbufferFromClientBuffer", reinterpret_cast<void*>(eglCreatePbufferFromClientBuffer)},
        {"eglCreatePbufferSurface", reinterpret_cast<void*>(eglCreatePbufferSurface)},
        {"eglCreatePixmapSurface", reinterpret_cast<void*>(eglCreatePixmapSurface)},
        {"eglCreateSyncKHR", reinterpret_cast<void*>(eglCreateSyncKHR)},
        {"eglCreateWindowSurface", reinterpret_cast<void*>(eglCreateWindowSurface)},
        {"eglDestroyContext", reinterpret_cast<void*>(eglDestroyContext)},
        {"eglDestroySurface", reinterpret_cast<void*>(eglDestroySurface)},
        {"eglDestroySyncKHR", reinterpret_cast<void*>(eglDestroySyncKHR)},
        {"eglGetConfigs", reinterpret_cast<void*>(eglGetConfigs)},
        {"eglGetCurrentContext", reinterpret_cast<void*>(eglGetCurrentContext)},
        {"eglGetCurrentDisplay", reinterpret_cast<void*>(eglGetCurrentDisplay)},
        {"eglGetCurrentSurface", reinterpret_cast<void*>(eglGetCurrentSurface)},
        {"eglGetDisplay", reinterpret_cast<void*>(eglGetDisplay)},
        {"eglGetError", reinterpret_cast<void*>(eglGetError)},
        {"eglGetSyncAttribKHR", reinterpret_cast<void*>(eglGetSyncAttribKHR)},
        {"eglInitialize", reinterpret_cast<void*>(eglInitialize)},
        {"eglMakeCurrent", reinterpret_cast<void*>(eglMakeCurrent)},
        {"eglQueryAPI", reinterpret_cast<void*>(eglQueryAPI)},
        {"eglQueryContext", reinterpret_cast<void*>(eglQueryContext)},
        {"eglQuerySurface", reinterpret_cast<void*>(eglQuerySurface)},
        {"eglQueryString", reinterpret_cast<void*>(eglQueryString)},
        {"eglReleaseTexImage", reinterpret_cast<void*>(eglReleaseTexImage)},
        {"eglReleaseThread", reinterpret_cast<void*>(eglReleaseThread)},
        {"eglSignalSyncKHR", reinterpret_cast<void*>(eglSignalSyncKHR)},
        {"eglSurfaceAttrib", reinterpret_cast<void*>(eglSurfaceAttrib)},
        {"eglSwapBuffers", reinterpret_cast<void*>(eglSwapBuffers)},
        {"eglSwapBuffersWithDamageKHR", reinterpret_cast<void*>(eglSwapBuffersWithDamageKHR)},
        {"eglSwapInterval", reinterpret_cast<void*>(eglSwapInterval)},
        {"eglTerminate", reinterpret_cast<void*>(eglTerminate)},
        {"eglWaitClient", reinterpret_cast<void*>(eglWaitClient)},
        {"eglWaitGL", reinterpret_cast<void*>(eglWaitGL)},
        {"eglWaitNative", reinterpret_cast<void*>(eglWaitNative)},
        {"eglCreateImageKHR", reinterpret_cast<void*>(eglCreateImageKHR)},
        {"eglDestroyImageKHR", reinterpret_cast<void*>(eglDestroyImageKHR)},
        {"eglCreateNativeClientBufferANDROID", reinterpret_cast<void*>(eglCreateNativeClientBufferANDROID)},
        {"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)},
        {"glClearPixelLocalStorageuiEXT", reinterpret_cast<void*>(glClearPixelLocalStorageuiEXT)},
        {"glClearTexImageEXT", reinterpret_cast<void*>(glClearTexImageEXT)},
        {"glClearTexSubImageEXT", reinterpret_cast<void*>(glClearTexSubImageEXT)},
        {"glConservativeRasterParameteriNV", reinterpret_cast<void*>(glConservativeRasterParameteriNV)},
        {"glDepthRangeArrayfvOES", reinterpret_cast<void*>(glDepthRangeArrayfvOES)},
        {"glDepthRangeIndexedfOES", reinterpret_cast<void*>(glDepthRangeIndexedfOES)},
        {"glDrawTransformFeedbackEXT", reinterpret_cast<void*>(glDrawTransformFeedbackEXT)},
        {"glDrawTransformFeedbackInstancedEXT", reinterpret_cast<void*>(glDrawTransformFeedbackInstancedEXT)},
        {"glFramebufferPixelLocalStorageSizeEXT", reinterpret_cast<void*>(glFramebufferPixelLocalStorageSizeEXT)},
        {"glFramebufferTexture2DDownsampleIMG", reinterpret_cast<void*>(glFramebufferTexture2DDownsampleIMG)},
        {"glFramebufferTextureLayerDownsampleIMG", reinterpret_cast<void*>(glFramebufferTextureLayerDownsampleIMG)},
        {"glFramebufferTextureMultisampleMultiviewOVR", reinterpret_cast<void*>(glFramebufferTextureMultisampleMultiviewOVR)},
        {"glGetFloati_vOES", reinterpret_cast<void*>(glGetFloati_vOES)},
        {"glGetFramebufferPixelLocalStorageSizeEXT", reinterpret_cast<void*>(glGetFramebufferPixelLocalStorageSizeEXT)},
        {"glGetTextureHandleIMG", reinterpret_cast<void*>(glGetTextureHandleIMG)},
        {"glGetTextureSamplerHandleIMG", reinterpret_cast<void*>(glGetTextureSamplerHandleIMG)},
        {"glGetUniformi64vNV", reinterpret_cast<void*>(glGetUniformi64vNV)},
        {"glPolygonOffsetClampEXT", reinterpret_cast<void*>(glPolygonOffsetClampEXT)},
        {"glProgramUniform1i64NV", reinterpret_cast<void*>(glProgramUniform1i64NV)},
        {"glProgramUniform1i64vNV", reinterpret_cast<void*>(glProgramUniform1i64vNV)},
        {"glProgramUniform1ui64NV", reinterpret_cast<void*>(glProgramUniform1ui64NV)},
        {"glProgramUniform1ui64vNV", reinterpret_cast<void*>(glProgramUniform1ui64vNV)},
        {"glProgramUniform2i64NV", reinterpret_cast<void*>(glProgramUniform2i64NV)},
        {"glProgramUniform2i64vNV", reinterpret_cast<void*>(glProgramUniform2i64vNV)},
        {"glProgramUniform2ui64NV", reinterpret_cast<void*>(glProgramUniform2ui64NV)},
        {"glProgramUniform2ui64vNV", reinterpret_cast<void*>(glProgramUniform2ui64vNV)},
        {"glProgramUniform3i64NV", reinterpret_cast<void*>(glProgramUniform3i64NV)},
        {"glProgramUniform3i64vNV", reinterpret_cast<void*>(glProgramUniform3i64vNV)},
        {"glProgramUniform3ui64NV", reinterpret_cast<void*>(glProgramUniform3ui64NV)},
        {"glProgramUniform3ui64vNV", reinterpret_cast<void*>(glProgramUniform3ui64vNV)},
        {"glProgramUniform4i64NV", reinterpret_cast<void*>(glProgramUniform4i64NV)},
        {"glProgramUniform4i64vNV", reinterpret_cast<void*>(glProgramUniform4i64vNV)},
        {"glProgramUniform4ui64NV", reinterpret_cast<void*>(glProgramUniform4ui64NV)},
        {"glProgramUniform4ui64vNV", reinterpret_cast<void*>(glProgramUniform4ui64vNV)},
        {"glProgramUniformHandleui64IMG", reinterpret_cast<void*>(glProgramUniformHandleui64IMG)},
        {"glProgramUniformHandleui64vIMG", reinterpret_cast<void*>(glProgramUniformHandleui64vIMG)},
        {"glScissorArrayvOES", reinterpret_cast<void*>(glScissorArrayvOES)},
        {"glScissorIndexedOES", reinterpret_cast<void*>(glScissorIndexedOES)},
        {"glScissorIndexedvOES", reinterpret_cast<void*>(glScissorIndexedvOES)},
        {"glUniform1i64NV", reinterpret_cast<void*>(glUniform1i64NV)},
        {"glUniform1i64vNV", reinterpret_cast<void*>(glUniform1i64vNV)},
        {"glUniform1ui64NV", reinterpret_cast<void*>(glUniform1ui64NV)},
        {"glUniform1ui64vNV", reinterpret_cast<void*>(glUniform1ui64vNV)},
        {"glUniform2i64NV", reinterpret_cast<void*>(glUniform2i64NV)},
        {"glUniform2i64vNV", reinterpret_cast<void*>(glUniform2i64vNV)},
        {"glUniform2ui64NV", reinterpret_cast<void*>(glUniform2ui64NV)},
        {"glUniform2ui64vNV", reinterpret_cast<void*>(glUniform2ui64vNV)},
        {"glUniform3i64NV", reinterpret_cast<void*>(glUniform3i64NV)},
        {"glUniform3i64vNV", reinterpret_cast<void*>(glUniform3i64vNV)},
        {"glUniform3ui64NV", reinterpret_cast<void*>(glUniform3ui64NV)},
        {"glUniform3ui64vNV", reinterpret_cast<void*>(glUniform3ui64vNV)},
        {"glUniform4i64NV", reinterpret_cast<void*>(glUniform4i64NV)},
        {"glUniform4i64vNV", reinterpret_cast<void*>(glUniform4i64vNV)},
        {"glUniform4ui64NV", reinterpret_cast<void*>(glUniform4ui64NV)},
        {"glUniform4ui64vNV", reinterpret_cast<void*>(glUniform4ui64vNV)},
        {"glUniformHandleui64IMG", reinterpret_cast<void*>(glUniformHandleui64IMG)},
        {"glUniformHandleui64vIMG", reinterpret_cast<void*>(glUniformHandleui64vIMG)},
        {"glViewportArrayvOES", reinterpret_cast<void*>(glViewportArrayvOES)},
        {"glViewportIndexedfOES", reinterpret_cast<void*>(glViewportIndexedfOES)},
        {"glViewportIndexedfvOES", reinterpret_cast<void*>(glViewportIndexedfvOES)},
        {"glViewportSwizzleNV", reinterpret_cast<void*>(glViewportSwizzleNV)},
        {"glWindowRectanglesEXT", reinterpret_cast<void*>(glWindowRectanglesEXT)},
        {"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)},
        {"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)},
        {"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)},
        {"glTexStorage1D", reinterpret_cast<void*>(glTexStorage1D)},
        {"glBindFragDataLocation", reinterpret_cast<void*>(glBindFragDataLocation)},
        {"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::GetGlesProcAddress(name, true);
    }
}

} // anonymous namespace

extern "C" {

EXPORT void STDCALL glBlendBarrierKHR() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendBarrierKHR()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendBarrierKHR");
    s->glBlendBarrierKHR(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationSeparateiEXT");
    s->glBlendEquationSeparateiEXT(&observer, buf, modeRGB, modeAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationiEXT");
    s->glBlendEquationiEXT(&observer, buf, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFuncSeparateiEXT");
    s->glBlendFuncSeparateiEXT(&observer, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFunciEXT");
    s->glBlendFunciEXT(&observer, buf, src, dst);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColorMaskiEXT");
    s->glColorMaskiEXT(&observer, index, r, g, b, a);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyImageSubDataEXT");
    s->glCopyImageSubDataEXT(&observer, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDebugMessageCallbackKHR");
    s->glDebugMessageCallbackKHR(&observer, callback, userParam);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDebugMessageControlKHR");
    s->glDebugMessageControlKHR(&observer, source, type, severity, count, ids, enabled);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDebugMessageInsertKHR");
    s->glDebugMessageInsertKHR(&observer, source, type, id, severity, length, message);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisableiEXT");
    s->glDisableiEXT(&observer, target, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnableiEXT");
    s->glEnableiEXT(&observer, target, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTextureEXT");
    s->glFramebufferTextureEXT(&observer, target, attachment, texture, level);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetDebugMessageLogKHR");
    auto _result_ = s->glGetDebugMessageLogKHR(&observer, count, bufSize, sources, types, ids, severities, lengths, messageLog);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetObjectLabelKHR");
    s->glGetObjectLabelKHR(&observer, identifier, name, bufSize, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetObjectPtrLabelKHR");
    s->glGetObjectPtrLabelKHR(&observer, ptr, bufSize, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPointervKHR");
    s->glGetPointervKHR(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterIivEXT");
    s->glGetSamplerParameterIivEXT(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterIuivEXT");
    s->glGetSamplerParameterIuivEXT(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterIivEXT");
    s->glGetTexParameterIivEXT(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterIuivEXT");
    s->glGetTexParameterIuivEXT(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsEnablediEXT");
    auto _result_ = s->glIsEnablediEXT(&observer, target, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsEnablediEXT() -- done");
    return _result_;
}
EXPORT void STDCALL glMinSampleShadingOES(GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMinSampleShadingOES(%f)", value);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMinSampleShadingOES");
    s->glMinSampleShadingOES(&observer, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glObjectLabelKHR");
    s->glObjectLabelKHR(&observer, identifier, name, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glObjectPtrLabelKHR");
    s->glObjectPtrLabelKHR(&observer, ptr, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPatchParameteriEXT");
    s->glPatchParameteriEXT(&observer, pname, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPatchParameteriEXT() -- done");
}
EXPORT void STDCALL glPopDebugGroupKHR() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopDebugGroupKHR()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPopDebugGroupKHR");
    s->glPopDebugGroupKHR(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPrimitiveBoundingBoxEXT");
    s->glPrimitiveBoundingBoxEXT(&observer, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPushDebugGroupKHR");
    s->glPushDebugGroupKHR(&observer, source, id, length, message);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterIivEXT");
    s->glSamplerParameterIivEXT(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterIuivEXT");
    s->glSamplerParameterIuivEXT(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexBufferEXT");
    s->glTexBufferEXT(&observer, target, internalformat, buffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexBufferRangeEXT");
    s->glTexBufferRangeEXT(&observer, target, internalformat, buffer, offset, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterIivEXT");
    s->glTexParameterIivEXT(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterIuivEXT");
    s->glTexParameterIuivEXT(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage3DMultisampleOES");
    s->glTexStorage3DMultisampleOES(&observer, target, samples, internalformat, width, height, depth, fixedsamplelocations);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBeginQuery");
    s->glBeginQuery(&observer, target, query);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteQueries");
    s->glDeleteQueries(&observer, count, queries);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeleteQueries() -- done");
}
EXPORT void STDCALL glEndQuery(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndQuery(%u)", target);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndQuery");
    s->glEndQuery(&observer, target);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenQueries");
    s->glGenQueries(&observer, count, queries);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjectuiv");
    s->glGetQueryObjectuiv(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryiv");
    s->glGetQueryiv(&observer, target, parameter, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetQueryiv() -- done");
}
EXPORT GLboolean STDCALL glIsQuery(QueryId query) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsQuery(%" PRIu32 ")", query);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsQuery");
    auto _result_ = s->glIsQuery(&observer, query);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindBuffer");
    s->glBindBuffer(&observer, target, buffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindBufferBase");
    s->glBindBufferBase(&observer, target, index, buffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindBufferRange");
    s->glBindBufferRange(&observer, target, index, buffer, offset, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBufferData");
    s->glBufferData(&observer, target, size, data, usage);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBufferSubData");
    s->glBufferSubData(&observer, target, offset, size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyBufferSubData");
    s->glCopyBufferSubData(&observer, readTarget, writeTarget, readOffset, writeOffset, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteBuffers");
    s->glDeleteBuffers(&observer, count, buffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenBuffers");
    s->glGenBuffers(&observer, count, buffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetBufferParameteri64v");
    s->glGetBufferParameteri64v(&observer, target, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetBufferParameteriv");
    s->glGetBufferParameteriv(&observer, target, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetBufferPointerv");
    s->glGetBufferPointerv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetBufferPointerv() -- done");
}
EXPORT GLboolean STDCALL glIsBuffer(BufferId buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsBuffer(%" PRIu32 ")", buffer);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsBuffer");
    auto _result_ = s->glIsBuffer(&observer, buffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsBuffer() -- done");
    return _result_;
}
EXPORT void* STDCALL glMapBuffer(uint32_t target, uint32_t access) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMapBuffer(%u, %u)", target, access);
    if (!s->try_to_enter()) {
        GAPID_INFO("glMapBuffer at %p: GAPII re-entered. Just invoking imported function at %p", glMapBuffer, s->GlesSpy::imports().glMapBuffer);
        auto _result_ = s->GlesSpy::imports().glMapBuffer(target, access);
        GAPID_DEBUG("glMapBuffer() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMapBuffer");
    auto _result_ = s->glMapBuffer(&observer, target, access);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMapBuffer() -- 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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMapBufferRange");
    auto _result_ = s->glMapBufferRange(&observer, target, offset, length, access);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMapBufferRange() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glUnmapBuffer(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUnmapBuffer(%u)", target);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUnmapBuffer");
    auto _result_ = s->glUnmapBuffer(&observer, target);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUnmapBuffer() -- done");
    return _result_;
}
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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFlushMappedBufferRange");
    s->glFlushMappedBufferRange(&observer, target, offset, length);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFlushMappedBufferRange() -- done");
}
EXPORT void STDCALL glDebugMessageCallback(GLDEBUGPROC callback, void* userParam) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDebugMessageCallback(%p, %p)", callback, userParam);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDebugMessageCallback");
    s->glDebugMessageCallback(&observer, callback, userParam);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDebugMessageControl");
    s->glDebugMessageControl(&observer, source, type, severity, count, ids, enabled);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDebugMessageInsert");
    s->glDebugMessageInsert(&observer, source, type, id, severity, length, message);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetDebugMessageLog");
    auto _result_ = s->glGetDebugMessageLog(&observer, count, bufSize, sources, types, ids, severities, lengths, messageLog);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetObjectLabel");
    s->glGetObjectLabel(&observer, identifier, name, bufSize, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetObjectPtrLabel");
    s->glGetObjectPtrLabel(&observer, ptr, bufSize, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPointerv");
    s->glGetPointerv(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glObjectLabel");
    s->glObjectLabel(&observer, identifier, name, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glObjectPtrLabel");
    s->glObjectPtrLabel(&observer, ptr, length, label);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glObjectPtrLabel() -- done");
}
EXPORT void STDCALL glPopDebugGroup() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopDebugGroup()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPopDebugGroup");
    s->glPopDebugGroup(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPushDebugGroup");
    s->glPushDebugGroup(&observer, source, id, length, message);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArrays");
    s->glDrawArrays(&observer, draw_mode, first_index, indices_count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArraysIndirect");
    s->glDrawArraysIndirect(&observer, draw_mode, indirect);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArraysInstanced");
    s->glDrawArraysInstanced(&observer, draw_mode, first_index, indices_count, instance_count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElements");
    s->glDrawElements(&observer, draw_mode, indices_count, indices_type, indices);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsBaseVertex");
    s->glDrawElementsBaseVertex(&observer, draw_mode, indices_count, indices_type, indices, base_vertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsIndirect");
    s->glDrawElementsIndirect(&observer, draw_mode, indices_type, indirect);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstanced");
    s->glDrawElementsInstanced(&observer, draw_mode, indices_count, indices_type, indices, instance_count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedBaseVertex");
    s->glDrawElementsInstancedBaseVertex(&observer, draw_mode, indices_count, indices_type, indices, instance_count, base_vertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawRangeElements");
    s->glDrawRangeElements(&observer, draw_mode, start, end, indices_count, indices_type, indices);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawRangeElementsBaseVertex");
    s->glDrawRangeElementsBaseVertex(&observer, draw_mode, start, end, indices_count, indices_type, indices, base_vertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPatchParameteri");
    s->glPatchParameteri(&observer, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPrimitiveBoundingBox");
    s->glPrimitiveBoundingBox(&observer, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPrimitiveBoundingBox() -- done");
}
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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetConfigAttrib");
    auto _result_ = s->eglGetConfigAttrib(&observer, display, config, attribute, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetConfigAttrib() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglBindAPI(uint32_t api) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglBindAPI(%u)", api);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglBindAPI at %p: GAPII re-entered. Just invoking imported function at %p", eglBindAPI, s->GlesSpy::imports().eglBindAPI);
        auto _result_ = s->GlesSpy::imports().eglBindAPI(api);
        GAPID_DEBUG("eglBindAPI() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglBindAPI");
    auto _result_ = s->eglBindAPI(&observer, api);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglBindAPI() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglBindTexImage(EGLDisplay display, EGLSurface surface, EGLint buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglBindTexImage(%p, %p, %d)", display, surface, buffer);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglBindTexImage at %p: GAPII re-entered. Just invoking imported function at %p", eglBindTexImage, s->GlesSpy::imports().eglBindTexImage);
        auto _result_ = s->GlesSpy::imports().eglBindTexImage(display, surface, buffer);
        GAPID_DEBUG("eglBindTexImage() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglBindTexImage");
    auto _result_ = s->eglBindTexImage(&observer, display, surface, buffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglBindTexImage() -- 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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglChooseConfig");
    auto _result_ = s->eglChooseConfig(&observer, display, attrib_list, configs, config_size, num_config);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglChooseConfig() -- done");
    return _result_;
}
EXPORT EGLint STDCALL eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint sync_flags, EGLTimeKHR timeout) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglClientWaitSyncKHR(%p, %p, %d, %" PRIu64 ")", dpy, sync, sync_flags, timeout);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglClientWaitSyncKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglClientWaitSyncKHR, s->GlesSpy::imports().eglClientWaitSyncKHR);
        auto _result_ = s->GlesSpy::imports().eglClientWaitSyncKHR(dpy, sync, sync_flags, timeout);
        GAPID_DEBUG("eglClientWaitSyncKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglClientWaitSyncKHR");
    auto _result_ = s->eglClientWaitSyncKHR(&observer, dpy, sync, sync_flags, timeout);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglClientWaitSyncKHR() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglCopyBuffers(EGLDisplay display, EGLSurface surface, EGLNativePixmapType native_pixmap) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCopyBuffers(%p, %p, %p)", display, surface, native_pixmap);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCopyBuffers at %p: GAPII re-entered. Just invoking imported function at %p", eglCopyBuffers, s->GlesSpy::imports().eglCopyBuffers);
        auto _result_ = s->GlesSpy::imports().eglCopyBuffers(display, surface, native_pixmap);
        GAPID_DEBUG("eglCopyBuffers() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCopyBuffers");
    auto _result_ = s->eglCopyBuffers(&observer, display, surface, native_pixmap);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCopyBuffers() -- 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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreateContext");
    auto _result_ = s->eglCreateContext(&observer, display, config, share_context, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreateContext() -- done");
    return _result_;
}
EXPORT EGLSurface STDCALL eglCreatePbufferFromClientBuffer(EGLDisplay display, uint32_t buftype, EGLClientBuffer buffer, EGLConfig config, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreatePbufferFromClientBuffer(%p, %u, %p, %p, %p)", display, buftype, buffer, config, attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreatePbufferFromClientBuffer at %p: GAPII re-entered. Just invoking imported function at %p", eglCreatePbufferFromClientBuffer, s->GlesSpy::imports().eglCreatePbufferFromClientBuffer);
        auto _result_ = s->GlesSpy::imports().eglCreatePbufferFromClientBuffer(display, buftype, buffer, config, attrib_list);
        GAPID_DEBUG("eglCreatePbufferFromClientBuffer() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreatePbufferFromClientBuffer");
    auto _result_ = s->eglCreatePbufferFromClientBuffer(&observer, display, buftype, buffer, config, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreatePbufferFromClientBuffer() -- done");
    return _result_;
}
EXPORT EGLSurface STDCALL eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreatePbufferSurface(%p, %p, %p)", display, config, attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreatePbufferSurface at %p: GAPII re-entered. Just invoking imported function at %p", eglCreatePbufferSurface, s->GlesSpy::imports().eglCreatePbufferSurface);
        auto _result_ = s->GlesSpy::imports().eglCreatePbufferSurface(display, config, attrib_list);
        GAPID_DEBUG("eglCreatePbufferSurface() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreatePbufferSurface");
    auto _result_ = s->eglCreatePbufferSurface(&observer, display, config, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreatePbufferSurface() -- done");
    return _result_;
}
EXPORT EGLSurface STDCALL eglCreatePixmapSurface(EGLDisplay display, EGLConfig config, EGLNativePixmapType native_pixmap, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreatePixmapSurface(%p, %p, %p, %p)", display, config, native_pixmap, attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreatePixmapSurface at %p: GAPII re-entered. Just invoking imported function at %p", eglCreatePixmapSurface, s->GlesSpy::imports().eglCreatePixmapSurface);
        auto _result_ = s->GlesSpy::imports().eglCreatePixmapSurface(display, config, native_pixmap, attrib_list);
        GAPID_DEBUG("eglCreatePixmapSurface() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreatePixmapSurface");
    auto _result_ = s->eglCreatePixmapSurface(&observer, display, config, native_pixmap, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreatePixmapSurface() -- done");
    return _result_;
}
EXPORT EGLSyncKHR STDCALL eglCreateSyncKHR(EGLDisplay dpy, uint32_t type, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreateSyncKHR(%p, %u, %p)", dpy, type, attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreateSyncKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglCreateSyncKHR, s->GlesSpy::imports().eglCreateSyncKHR);
        auto _result_ = s->GlesSpy::imports().eglCreateSyncKHR(dpy, type, attrib_list);
        GAPID_DEBUG("eglCreateSyncKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreateSyncKHR");
    auto _result_ = s->eglCreateSyncKHR(&observer, dpy, type, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreateSyncKHR() -- done");
    return _result_;
}
EXPORT EGLSurface STDCALL eglCreateWindowSurface(EGLDisplay display, EGLConfig config, EGLNativeWindowType native_window, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreateWindowSurface(%p, %p, %p, %p)", display, config, native_window, attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreateWindowSurface at %p: GAPII re-entered. Just invoking imported function at %p", eglCreateWindowSurface, s->GlesSpy::imports().eglCreateWindowSurface);
        auto _result_ = s->GlesSpy::imports().eglCreateWindowSurface(display, config, native_window, attrib_list);
        GAPID_DEBUG("eglCreateWindowSurface() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreateWindowSurface");
    auto _result_ = s->eglCreateWindowSurface(&observer, display, config, native_window, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreateWindowSurface() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglDestroyContext(EGLDisplay display, EGLContext context) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglDestroyContext(%p, %p)", display, context);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglDestroyContext at %p: GAPII re-entered. Just invoking imported function at %p", eglDestroyContext, s->GlesSpy::imports().eglDestroyContext);
        auto _result_ = s->GlesSpy::imports().eglDestroyContext(display, context);
        GAPID_DEBUG("eglDestroyContext() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglDestroyContext");
    auto _result_ = s->eglDestroyContext(&observer, display, context);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglDestroyContext() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglDestroySurface(EGLDisplay display, EGLSurface surface) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglDestroySurface(%p, %p)", display, surface);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglDestroySurface at %p: GAPII re-entered. Just invoking imported function at %p", eglDestroySurface, s->GlesSpy::imports().eglDestroySurface);
        auto _result_ = s->GlesSpy::imports().eglDestroySurface(display, surface);
        GAPID_DEBUG("eglDestroySurface() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglDestroySurface");
    auto _result_ = s->eglDestroySurface(&observer, display, surface);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglDestroySurface() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglDestroySyncKHR(%p, %p)", dpy, sync);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglDestroySyncKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglDestroySyncKHR, s->GlesSpy::imports().eglDestroySyncKHR);
        auto _result_ = s->GlesSpy::imports().eglDestroySyncKHR(dpy, sync);
        GAPID_DEBUG("eglDestroySyncKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglDestroySyncKHR");
    auto _result_ = s->eglDestroySyncKHR(&observer, dpy, sync);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglDestroySyncKHR() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglGetConfigs(EGLDisplay display, EGLConfig* configs, EGLint config_size, EGLint* num_config) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetConfigs(%p, %p, %d, %p)", display, configs, config_size, num_config);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetConfigs at %p: GAPII re-entered. Just invoking imported function at %p", eglGetConfigs, s->GlesSpy::imports().eglGetConfigs);
        auto _result_ = s->GlesSpy::imports().eglGetConfigs(display, configs, config_size, num_config);
        GAPID_DEBUG("eglGetConfigs() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetConfigs");
    auto _result_ = s->eglGetConfigs(&observer, display, configs, config_size, num_config);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetConfigs() -- done");
    return _result_;
}
EXPORT EGLContext STDCALL eglGetCurrentContext() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetCurrentContext()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetCurrentContext at %p: GAPII re-entered. Just invoking imported function at %p", eglGetCurrentContext, s->GlesSpy::imports().eglGetCurrentContext);
        auto _result_ = s->GlesSpy::imports().eglGetCurrentContext();
        GAPID_DEBUG("eglGetCurrentContext() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetCurrentContext");
    auto _result_ = s->eglGetCurrentContext(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetCurrentContext() -- done");
    return _result_;
}
EXPORT EGLDisplay STDCALL eglGetCurrentDisplay() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetCurrentDisplay()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetCurrentDisplay at %p: GAPII re-entered. Just invoking imported function at %p", eglGetCurrentDisplay, s->GlesSpy::imports().eglGetCurrentDisplay);
        auto _result_ = s->GlesSpy::imports().eglGetCurrentDisplay();
        GAPID_DEBUG("eglGetCurrentDisplay() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetCurrentDisplay");
    auto _result_ = s->eglGetCurrentDisplay(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetCurrentDisplay() -- done");
    return _result_;
}
EXPORT EGLSurface STDCALL eglGetCurrentSurface(EGLint readdraw) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetCurrentSurface(%d)", readdraw);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetCurrentSurface at %p: GAPII re-entered. Just invoking imported function at %p", eglGetCurrentSurface, s->GlesSpy::imports().eglGetCurrentSurface);
        auto _result_ = s->GlesSpy::imports().eglGetCurrentSurface(readdraw);
        GAPID_DEBUG("eglGetCurrentSurface() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetCurrentSurface");
    auto _result_ = s->eglGetCurrentSurface(&observer, readdraw);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetCurrentSurface() -- done");
    return _result_;
}
EXPORT EGLDisplay STDCALL eglGetDisplay(EGLNativeDisplayType native_display) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetDisplay(%d)", native_display);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetDisplay at %p: GAPII re-entered. Just invoking imported function at %p", eglGetDisplay, s->GlesSpy::imports().eglGetDisplay);
        auto _result_ = s->GlesSpy::imports().eglGetDisplay(native_display);
        GAPID_DEBUG("eglGetDisplay() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetDisplay");
    auto _result_ = s->eglGetDisplay(&observer, native_display);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetDisplay() -- done");
    return _result_;
}
EXPORT EGLint STDCALL eglGetError() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetError()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetError at %p: GAPII re-entered. Just invoking imported function at %p", eglGetError, s->GlesSpy::imports().eglGetError);
        auto _result_ = s->GlesSpy::imports().eglGetError();
        GAPID_DEBUG("eglGetError() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetError");
    auto _result_ = s->eglGetError(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetError() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglGetSyncAttribKHR(%p, %p, %d, %p)", dpy, sync, attribute, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglGetSyncAttribKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglGetSyncAttribKHR, s->GlesSpy::imports().eglGetSyncAttribKHR);
        auto _result_ = s->GlesSpy::imports().eglGetSyncAttribKHR(dpy, sync, attribute, value);
        GAPID_DEBUG("eglGetSyncAttribKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglGetSyncAttribKHR");
    auto _result_ = s->eglGetSyncAttribKHR(&observer, dpy, sync, attribute, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglGetSyncAttribKHR() -- done");
    return _result_;
}
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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglInitialize");
    auto _result_ = s->eglInitialize(&observer, dpy, major, minor);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglInitialize() -- 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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglMakeCurrent");
    auto _result_ = s->eglMakeCurrent(&observer, display, draw, read, context);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglMakeCurrent() -- done");
    return _result_;
}
EXPORT uint32_t STDCALL eglQueryAPI() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglQueryAPI()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglQueryAPI at %p: GAPII re-entered. Just invoking imported function at %p", eglQueryAPI, s->GlesSpy::imports().eglQueryAPI);
        auto _result_ = s->GlesSpy::imports().eglQueryAPI();
        GAPID_DEBUG("eglQueryAPI() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglQueryAPI");
    auto _result_ = s->eglQueryAPI(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglQueryAPI() -- 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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglQueryContext");
    auto _result_ = s->eglQueryContext(&observer, display, context, attribute, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglQueryContext() -- 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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglQuerySurface");
    auto _result_ = s->eglQuerySurface(&observer, display, surface, attribute, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglQuerySurface() -- done");
    return _result_;
}
EXPORT char* STDCALL eglQueryString(EGLDisplay display, EGLint name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglQueryString(%p, %d)", display, name);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglQueryString at %p: GAPII re-entered. Just invoking imported function at %p", eglQueryString, s->GlesSpy::imports().eglQueryString);
        auto _result_ = s->GlesSpy::imports().eglQueryString(display, name);
        GAPID_DEBUG("eglQueryString() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglQueryString");
    auto _result_ = s->eglQueryString(&observer, display, name);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglQueryString() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglReleaseTexImage(EGLDisplay display, EGLSurface surface, EGLint buffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglReleaseTexImage(%p, %p, %d)", display, surface, buffer);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglReleaseTexImage at %p: GAPII re-entered. Just invoking imported function at %p", eglReleaseTexImage, s->GlesSpy::imports().eglReleaseTexImage);
        auto _result_ = s->GlesSpy::imports().eglReleaseTexImage(display, surface, buffer);
        GAPID_DEBUG("eglReleaseTexImage() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglReleaseTexImage");
    auto _result_ = s->eglReleaseTexImage(&observer, display, surface, buffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglReleaseTexImage() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglReleaseThread() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglReleaseThread()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglReleaseThread at %p: GAPII re-entered. Just invoking imported function at %p", eglReleaseThread, s->GlesSpy::imports().eglReleaseThread);
        auto _result_ = s->GlesSpy::imports().eglReleaseThread();
        GAPID_DEBUG("eglReleaseThread() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglReleaseThread");
    auto _result_ = s->eglReleaseThread(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglReleaseThread() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglSignalSyncKHR(%p, %p, %u)", dpy, sync, mode);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglSignalSyncKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglSignalSyncKHR, s->GlesSpy::imports().eglSignalSyncKHR);
        auto _result_ = s->GlesSpy::imports().eglSignalSyncKHR(dpy, sync, mode);
        GAPID_DEBUG("eglSignalSyncKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglSignalSyncKHR");
    auto _result_ = s->eglSignalSyncKHR(&observer, dpy, sync, mode);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglSignalSyncKHR() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglSurfaceAttrib(EGLDisplay display, EGLSurface surface, EGLint attribute, EGLint value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglSurfaceAttrib(%p, %p, %d, %d)", display, surface, attribute, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglSurfaceAttrib at %p: GAPII re-entered. Just invoking imported function at %p", eglSurfaceAttrib, s->GlesSpy::imports().eglSurfaceAttrib);
        auto _result_ = s->GlesSpy::imports().eglSurfaceAttrib(display, surface, attribute, value);
        GAPID_DEBUG("eglSurfaceAttrib() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglSurfaceAttrib");
    auto _result_ = s->eglSurfaceAttrib(&observer, display, surface, attribute, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglSurfaceAttrib() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglSwapBuffers(EGLDisplay display, void* surface) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglSwapBuffers(%p, %p)", display, surface);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglSwapBuffers");
    auto _result_ = s->eglSwapBuffers(&observer, display, surface);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglSwapBuffersWithDamageKHR");
    auto _result_ = s->eglSwapBuffersWithDamageKHR(&observer, dpy, surface, rects, n_rects);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglSwapBuffersWithDamageKHR() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglSwapInterval(EGLDisplay display, EGLint interval) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglSwapInterval(%p, %d)", display, interval);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglSwapInterval at %p: GAPII re-entered. Just invoking imported function at %p", eglSwapInterval, s->GlesSpy::imports().eglSwapInterval);
        auto _result_ = s->GlesSpy::imports().eglSwapInterval(display, interval);
        GAPID_DEBUG("eglSwapInterval() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglSwapInterval");
    auto _result_ = s->eglSwapInterval(&observer, display, interval);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglSwapInterval() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglTerminate(EGLDisplay display) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglTerminate(%p)", display);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglTerminate at %p: GAPII re-entered. Just invoking imported function at %p", eglTerminate, s->GlesSpy::imports().eglTerminate);
        auto _result_ = s->GlesSpy::imports().eglTerminate(display);
        GAPID_DEBUG("eglTerminate() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglTerminate");
    auto _result_ = s->eglTerminate(&observer, display);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglTerminate() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglWaitClient() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglWaitClient()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglWaitClient at %p: GAPII re-entered. Just invoking imported function at %p", eglWaitClient, s->GlesSpy::imports().eglWaitClient);
        auto _result_ = s->GlesSpy::imports().eglWaitClient();
        GAPID_DEBUG("eglWaitClient() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglWaitClient");
    auto _result_ = s->eglWaitClient(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglWaitClient() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglWaitGL() {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglWaitGL()");
    if (!s->try_to_enter()) {
        GAPID_INFO("eglWaitGL at %p: GAPII re-entered. Just invoking imported function at %p", eglWaitGL, s->GlesSpy::imports().eglWaitGL);
        auto _result_ = s->GlesSpy::imports().eglWaitGL();
        GAPID_DEBUG("eglWaitGL() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglWaitGL");
    auto _result_ = s->eglWaitGL(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglWaitGL() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglWaitNative(EGLint engine) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglWaitNative(%d)", engine);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglWaitNative at %p: GAPII re-entered. Just invoking imported function at %p", eglWaitNative, s->GlesSpy::imports().eglWaitNative);
        auto _result_ = s->GlesSpy::imports().eglWaitNative(engine);
        GAPID_DEBUG("eglWaitNative() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglWaitNative");
    auto _result_ = s->eglWaitNative(&observer, engine);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglWaitNative() -- done");
    return _result_;
}
EXPORT EGLImageKHR STDCALL eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, uint32_t target, EGLClientBuffer buffer, EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreateImageKHR(%p, %p, %u, %p, %p)", dpy, ctx, target, buffer, attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreateImageKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglCreateImageKHR, s->GlesSpy::imports().eglCreateImageKHR);
        auto _result_ = s->GlesSpy::imports().eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
        GAPID_DEBUG("eglCreateImageKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreateImageKHR");
    auto _result_ = s->eglCreateImageKHR(&observer, dpy, ctx, target, buffer, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreateImageKHR() -- done");
    return _result_;
}
EXPORT EGLBoolean STDCALL eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglDestroyImageKHR(%p, %p)", dpy, image);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglDestroyImageKHR at %p: GAPII re-entered. Just invoking imported function at %p", eglDestroyImageKHR, s->GlesSpy::imports().eglDestroyImageKHR);
        auto _result_ = s->GlesSpy::imports().eglDestroyImageKHR(dpy, image);
        GAPID_DEBUG("eglDestroyImageKHR() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglDestroyImageKHR");
    auto _result_ = s->eglDestroyImageKHR(&observer, dpy, image);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglDestroyImageKHR() -- done");
    return _result_;
}
EXPORT EGLClientBuffer STDCALL eglCreateNativeClientBufferANDROID(EGLint* attrib_list) {
    Spy* s = Spy::get();
    GAPID_DEBUG("eglCreateNativeClientBufferANDROID(%p)", attrib_list);
    if (!s->try_to_enter()) {
        GAPID_INFO("eglCreateNativeClientBufferANDROID at %p: GAPII re-entered. Just invoking imported function at %p", eglCreateNativeClientBufferANDROID, s->GlesSpy::imports().eglCreateNativeClientBufferANDROID);
        auto _result_ = s->GlesSpy::imports().eglCreateNativeClientBufferANDROID(attrib_list);
        GAPID_DEBUG("eglCreateNativeClientBufferANDROID() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "eglCreateNativeClientBufferANDROID");
    auto _result_ = s->eglCreateNativeClientBufferANDROID(&observer, attrib_list);
    s->unlock();
    s->exit();
    GAPID_DEBUG("eglCreateNativeClientBufferANDROID() -- done");
    return _result_;
}
EXPORT void STDCALL glActiveShaderProgramEXT(PipelineId pipeline, ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glActiveShaderProgramEXT(%" PRIu32 ", %" PRIu32 ")", pipeline, program);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glActiveShaderProgramEXT");
    s->glActiveShaderProgramEXT(&observer, pipeline, program);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glAlphaFuncQCOM");
    s->glAlphaFuncQCOM(&observer, func, ref);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glAlphaFuncQCOM() -- done");
}
EXPORT void STDCALL glApplyFramebufferAttachmentCMAAINTEL() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glApplyFramebufferAttachmentCMAAINTEL()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glApplyFramebufferAttachmentCMAAINTEL");
    s->glApplyFramebufferAttachmentCMAAINTEL(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBeginConditionalRenderNV");
    s->glBeginConditionalRenderNV(&observer, id, mode);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBeginConditionalRenderNV() -- done");
}
EXPORT void STDCALL glBeginPerfMonitorAMD(GLuint monitor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginPerfMonitorAMD(%" PRIu32 ")", monitor);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBeginPerfMonitorAMD");
    s->glBeginPerfMonitorAMD(&observer, monitor);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBeginPerfMonitorAMD() -- done");
}
EXPORT void STDCALL glBeginPerfQueryINTEL(GLuint queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginPerfQueryINTEL(%" PRIu32 ")", queryHandle);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBeginPerfQueryINTEL");
    s->glBeginPerfQueryINTEL(&observer, queryHandle);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBeginQueryEXT");
    s->glBeginQueryEXT(&observer, target, query);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindFragDataLocationEXT");
    s->glBindFragDataLocationEXT(&observer, program, color, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindFragDataLocationIndexedEXT");
    s->glBindFragDataLocationIndexedEXT(&observer, program, colorNumber, index, name);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindFragDataLocationIndexedEXT() -- done");
}
EXPORT void STDCALL glBindProgramPipelineEXT(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindProgramPipelineEXT(%" PRIu32 ")", pipeline);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindProgramPipelineEXT");
    s->glBindProgramPipelineEXT(&observer, pipeline);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindProgramPipelineEXT() -- done");
}
EXPORT void STDCALL glBindVertexArrayOES(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindVertexArrayOES(%" PRIu32 ")", array);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindVertexArrayOES");
    s->glBindVertexArrayOES(&observer, array);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindVertexArrayOES() -- done");
}
EXPORT void STDCALL glBlendBarrierNV() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendBarrierNV()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendBarrierNV");
    s->glBlendBarrierNV(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationSeparateiOES");
    s->glBlendEquationSeparateiOES(&observer, buf, modeRGB, modeAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationiOES");
    s->glBlendEquationiOES(&observer, buf, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFuncSeparateiOES");
    s->glBlendFuncSeparateiOES(&observer, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFunciOES");
    s->glBlendFunciOES(&observer, buf, src, dst);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendParameteriNV");
    s->glBlendParameteriNV(&observer, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlitFramebufferANGLE");
    s->glBlitFramebufferANGLE(&observer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlitFramebufferNV");
    s->glBlitFramebufferNV(&observer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBufferStorageEXT");
    s->glBufferStorageEXT(&observer, target, size, data, flag);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClientWaitSyncAPPLE");
    auto _result_ = s->glClientWaitSyncAPPLE(&observer, sync, flag, timeout);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColorMaskiOES");
    s->glColorMaskiOES(&observer, index, r, g, b, a);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompressedTexImage3DOES");
    s->glCompressedTexImage3DOES(&observer, target, level, internalformat, width, height, depth, border, image_size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompressedTexSubImage3DOES");
    s->glCompressedTexSubImage3DOES(&observer, target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyBufferSubDataNV");
    s->glCopyBufferSubDataNV(&observer, readTarget, writeTarget, readOffset, writeOffset, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyImageSubDataOES");
    s->glCopyImageSubDataOES(&observer, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyPathNV");
    s->glCopyPathNV(&observer, resultPath, srcPath);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyTexSubImage3DOES");
    s->glCopyTexSubImage3DOES(&observer, target, level, xoffset, yoffset, zoffset, x, y, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyTextureLevelsAPPLE");
    s->glCopyTextureLevelsAPPLE(&observer, destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverFillPathInstancedNV");
    s->glCoverFillPathInstancedNV(&observer, numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverFillPathNV");
    s->glCoverFillPathNV(&observer, path, coverMode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverStrokePathInstancedNV");
    s->glCoverStrokePathInstancedNV(&observer, numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverStrokePathNV");
    s->glCoverStrokePathNV(&observer, path, coverMode);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCoverStrokePathNV() -- done");
}
EXPORT void STDCALL glCoverageMaskNV(GLboolean mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageMaskNV(%" PRIu8 ")", mask);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverageMaskNV");
    s->glCoverageMaskNV(&observer, mask);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCoverageMaskNV() -- done");
}
EXPORT void STDCALL glCoverageModulationNV(uint32_t components) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageModulationNV(%u)", components);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverageModulationNV");
    s->glCoverageModulationNV(&observer, components);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverageModulationTableNV");
    s->glCoverageModulationTableNV(&observer, n, v);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCoverageModulationTableNV() -- done");
}
EXPORT void STDCALL glCoverageOperationNV(uint32_t operation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCoverageOperationNV(%u)", operation);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCoverageOperationNV");
    s->glCoverageOperationNV(&observer, operation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCreatePerfQueryINTEL");
    s->glCreatePerfQueryINTEL(&observer, queryId, queryHandle);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCreateShaderProgramvEXT");
    auto _result_ = s->glCreateShaderProgramvEXT(&observer, type, count, strings);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteFencesNV");
    s->glDeleteFencesNV(&observer, n, fences);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeletePathsNV");
    s->glDeletePathsNV(&observer, path, range);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeletePerfMonitorsAMD");
    s->glDeletePerfMonitorsAMD(&observer, n, monitors);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeletePerfMonitorsAMD() -- done");
}
EXPORT void STDCALL glDeletePerfQueryINTEL(GLuint queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeletePerfQueryINTEL(%" PRIu32 ")", queryHandle);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeletePerfQueryINTEL");
    s->glDeletePerfQueryINTEL(&observer, queryHandle);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteProgramPipelinesEXT");
    s->glDeleteProgramPipelinesEXT(&observer, n, pipelines);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteQueriesEXT");
    s->glDeleteQueriesEXT(&observer, count, queries);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeleteQueriesEXT() -- done");
}
EXPORT void STDCALL glDeleteSyncAPPLE(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteSyncAPPLE(%p)", sync);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteSyncAPPLE");
    s->glDeleteSyncAPPLE(&observer, sync);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteVertexArraysOES");
    s->glDeleteVertexArraysOES(&observer, count, arrays);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangeArrayfvNV");
    s->glDepthRangeArrayfvNV(&observer, first, count, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangeIndexedfNV");
    s->glDepthRangeIndexedfNV(&observer, index, n, f);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDepthRangeIndexedfNV() -- done");
}
EXPORT void STDCALL glDisableDriverControlQCOM(GLuint driverControl) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableDriverControlQCOM(%" PRIu32 ")", driverControl);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisableDriverControlQCOM");
    s->glDisableDriverControlQCOM(&observer, driverControl);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisableiNV");
    s->glDisableiNV(&observer, target, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisableiOES");
    s->glDisableiOES(&observer, target, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDiscardFramebufferEXT");
    s->glDiscardFramebufferEXT(&observer, target, numAttachments, attachments);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArraysInstancedANGLE");
    s->glDrawArraysInstancedANGLE(&observer, mode, first, count, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArraysInstancedBaseInstanceEXT");
    s->glDrawArraysInstancedBaseInstanceEXT(&observer, mode, first, count, instancecount, baseinstance);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArraysInstancedEXT");
    s->glDrawArraysInstancedEXT(&observer, mode, start, count, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawArraysInstancedNV");
    s->glDrawArraysInstancedNV(&observer, mode, first, count, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawBuffersEXT");
    s->glDrawBuffersEXT(&observer, n, bufs);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawBuffersIndexedEXT");
    s->glDrawBuffersIndexedEXT(&observer, n, location, indices);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawBuffersNV");
    s->glDrawBuffersNV(&observer, n, bufs);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsBaseVertexEXT");
    s->glDrawElementsBaseVertexEXT(&observer, mode, count, type, indices, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsBaseVertexOES");
    s->glDrawElementsBaseVertexOES(&observer, mode, count, type, indices, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedANGLE");
    s->glDrawElementsInstancedANGLE(&observer, mode, count, type, indices, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedBaseInstanceEXT");
    s->glDrawElementsInstancedBaseInstanceEXT(&observer, mode, count, type, indices, instancecount, baseinstance);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedBaseVertexBaseInstanceEXT");
    s->glDrawElementsInstancedBaseVertexBaseInstanceEXT(&observer, mode, count, type, indices, instancecount, basevertex, baseinstance);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedBaseVertexEXT");
    s->glDrawElementsInstancedBaseVertexEXT(&observer, mode, count, type, indices, instancecount, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedBaseVertexOES");
    s->glDrawElementsInstancedBaseVertexOES(&observer, mode, count, type, indices, instancecount, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedEXT");
    s->glDrawElementsInstancedEXT(&observer, mode, count, type, indices, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawElementsInstancedNV");
    s->glDrawElementsInstancedNV(&observer, mode, count, type, indices, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawRangeElementsBaseVertexEXT");
    s->glDrawRangeElementsBaseVertexEXT(&observer, mode, start, end, count, type, indices, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawRangeElementsBaseVertexOES");
    s->glDrawRangeElementsBaseVertexOES(&observer, mode, start, end, count, type, indices, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEGLImageTargetRenderbufferStorageOES");
    s->glEGLImageTargetRenderbufferStorageOES(&observer, target, image);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEGLImageTargetTexture2DOES");
    s->glEGLImageTargetTexture2DOES(&observer, target, image);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEGLImageTargetTexture2DOES() -- done");
}
EXPORT void STDCALL glEnableDriverControlQCOM(GLuint driverControl) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableDriverControlQCOM(%" PRIu32 ")", driverControl);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnableDriverControlQCOM");
    s->glEnableDriverControlQCOM(&observer, driverControl);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnableiNV");
    s->glEnableiNV(&observer, target, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnableiOES");
    s->glEnableiOES(&observer, target, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEnableiOES() -- done");
}
EXPORT void STDCALL glEndConditionalRenderNV() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndConditionalRenderNV()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndConditionalRenderNV");
    s->glEndConditionalRenderNV(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEndConditionalRenderNV() -- done");
}
EXPORT void STDCALL glEndPerfMonitorAMD(GLuint monitor) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndPerfMonitorAMD(%" PRIu32 ")", monitor);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndPerfMonitorAMD");
    s->glEndPerfMonitorAMD(&observer, monitor);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEndPerfMonitorAMD() -- done");
}
EXPORT void STDCALL glEndPerfQueryINTEL(GLuint queryHandle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndPerfQueryINTEL(%" PRIu32 ")", queryHandle);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndPerfQueryINTEL");
    s->glEndPerfQueryINTEL(&observer, queryHandle);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEndPerfQueryINTEL() -- done");
}
EXPORT void STDCALL glEndQueryEXT(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndQueryEXT(%u)", target);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndQueryEXT");
    s->glEndQueryEXT(&observer, target);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEndQueryEXT() -- done");
}
EXPORT void STDCALL glEndTilingQCOM(uint32_t preserve_mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndTilingQCOM(%u)", preserve_mask);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndTilingQCOM");
    s->glEndTilingQCOM(&observer, preserve_mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetBufferPointervQCOM");
    s->glExtGetBufferPointervQCOM(&observer, target, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetBuffersQCOM");
    s->glExtGetBuffersQCOM(&observer, buffers, maxBuffers, numBuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetFramebuffersQCOM");
    s->glExtGetFramebuffersQCOM(&observer, framebuffers, maxFramebuffers, numFramebuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetProgramBinarySourceQCOM");
    s->glExtGetProgramBinarySourceQCOM(&observer, program, shadertype, source, length);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetProgramsQCOM");
    s->glExtGetProgramsQCOM(&observer, programs, maxPrograms, numPrograms);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetRenderbuffersQCOM");
    s->glExtGetRenderbuffersQCOM(&observer, renderbuffers, maxRenderbuffers, numRenderbuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetShadersQCOM");
    s->glExtGetShadersQCOM(&observer, shaders, maxShaders, numShaders);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetTexLevelParameterivQCOM");
    s->glExtGetTexLevelParameterivQCOM(&observer, texture, face, level, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetTexSubImageQCOM");
    s->glExtGetTexSubImageQCOM(&observer, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtGetTexturesQCOM");
    s->glExtGetTexturesQCOM(&observer, textures, maxTextures, numTextures);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glExtGetTexturesQCOM() -- done");
}
EXPORT GLboolean STDCALL glExtIsProgramBinaryQCOM(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glExtIsProgramBinaryQCOM(%" PRIu32 ")", program);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtIsProgramBinaryQCOM");
    auto _result_ = s->glExtIsProgramBinaryQCOM(&observer, program);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glExtTexObjectStateOverrideiQCOM");
    s->glExtTexObjectStateOverrideiQCOM(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFenceSyncAPPLE");
    auto _result_ = s->glFenceSyncAPPLE(&observer, condition, flag);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFenceSyncAPPLE() -- done");
    return _result_;
}
EXPORT void STDCALL glFinishFenceNV(GLuint fence) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFinishFenceNV(%" PRIu32 ")", fence);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFinishFenceNV");
    s->glFinishFenceNV(&observer, fence);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFlushMappedBufferRangeEXT");
    s->glFlushMappedBufferRangeEXT(&observer, target, offset, length);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFlushMappedBufferRangeEXT() -- done");
}
EXPORT void STDCALL glFragmentCoverageColorNV(GLuint color) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFragmentCoverageColorNV(%" PRIu32 ")", color);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFragmentCoverageColorNV");
    s->glFragmentCoverageColorNV(&observer, color);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferSampleLocationsfvNV");
    s->glFramebufferSampleLocationsfvNV(&observer, target, start, count, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture2DMultisampleEXT");
    s->glFramebufferTexture2DMultisampleEXT(&observer, target, attachment, textarget, texture, level, samples);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture2DMultisampleIMG");
    s->glFramebufferTexture2DMultisampleIMG(&observer, target, attachment, textarget, texture, level, samples);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture3DOES");
    s->glFramebufferTexture3DOES(&observer, target, attachment, textarget, texture, level, zoffset);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTextureMultiviewOVR");
    s->glFramebufferTextureMultiviewOVR(&observer, target, attachment, texture, level, baseViewIndex, numViews);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTextureOES");
    s->glFramebufferTextureOES(&observer, target, attachment, texture, level);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenFencesNV");
    s->glGenFencesNV(&observer, n, fences);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGenFencesNV() -- done");
}
EXPORT GLuint STDCALL glGenPathsNV(GLsizei range) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenPathsNV(%" PRId32 ")", range);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenPathsNV");
    auto _result_ = s->glGenPathsNV(&observer, range);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenPerfMonitorsAMD");
    s->glGenPerfMonitorsAMD(&observer, n, monitors);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenProgramPipelinesEXT");
    s->glGenProgramPipelinesEXT(&observer, n, pipelines);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenQueriesEXT");
    s->glGenQueriesEXT(&observer, count, queries);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenVertexArraysOES");
    s->glGenVertexArraysOES(&observer, count, arrays);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetBufferPointervOES");
    s->glGetBufferPointervOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetCoverageModulationTableNV");
    s->glGetCoverageModulationTableNV(&observer, bufsize, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetDriverControlStringQCOM");
    s->glGetDriverControlStringQCOM(&observer, driverControl, bufSize, length, driverControlString);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetDriverControlsQCOM");
    s->glGetDriverControlsQCOM(&observer, num, size, driverControls);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFenceivNV");
    s->glGetFenceivNV(&observer, fence, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetFenceivNV() -- done");
}
EXPORT void STDCALL glGetFirstPerfQueryIdINTEL(GLuint* queryId) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFirstPerfQueryIdINTEL(%p)", queryId);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFirstPerfQueryIdINTEL");
    s->glGetFirstPerfQueryIdINTEL(&observer, queryId);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFloati_vNV");
    s->glGetFloati_vNV(&observer, target, index, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFragDataIndexEXT");
    auto _result_ = s->glGetFragDataIndexEXT(&observer, program, name);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetFragDataIndexEXT() -- done");
    return _result_;
}
EXPORT uint32_t STDCALL glGetGraphicsResetStatusEXT() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetGraphicsResetStatusEXT()");
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetGraphicsResetStatusEXT");
    auto _result_ = s->glGetGraphicsResetStatusEXT(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetGraphicsResetStatusEXT() -- done");
    return _result_;
}
EXPORT uint32_t STDCALL glGetGraphicsResetStatusKHR() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetGraphicsResetStatusKHR()");
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetGraphicsResetStatusKHR");
    auto _result_ = s->glGetGraphicsResetStatusKHR(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetImageHandleNV");
    auto _result_ = s->glGetImageHandleNV(&observer, texture, level, layered, layer, format);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetInteger64vAPPLE");
    s->glGetInteger64vAPPLE(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetIntegeri_vEXT");
    s->glGetIntegeri_vEXT(&observer, target, index, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetInternalformatSampleivNV");
    s->glGetInternalformatSampleivNV(&observer, target, internalformat, samples, pname, bufSize, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetNextPerfQueryIdINTEL");
    s->glGetNextPerfQueryIdINTEL(&observer, queryId, nextQueryId);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetObjectLabelEXT");
    s->glGetObjectLabelEXT(&observer, type, object, bufSize, length, label);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathCommandsNV");
    s->glGetPathCommandsNV(&observer, path, commands);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathCoordsNV");
    s->glGetPathCoordsNV(&observer, path, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathDashArrayNV");
    s->glGetPathDashArrayNV(&observer, path, dashArray);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathLengthNV");
    auto _result_ = s->glGetPathLengthNV(&observer, path, startSegment, numSegments);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathMetricRangeNV");
    s->glGetPathMetricRangeNV(&observer, metricQueryMask, firstPathName, numPaths, stride, metrics);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathMetricsNV");
    s->glGetPathMetricsNV(&observer, metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathParameterfvNV");
    s->glGetPathParameterfvNV(&observer, path, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathParameterivNV");
    s->glGetPathParameterivNV(&observer, path, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPathSpacingNV");
    s->glGetPathSpacingNV(&observer, pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfCounterInfoINTEL");
    s->glGetPerfCounterInfoINTEL(&observer, queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfMonitorCounterDataAMD");
    s->glGetPerfMonitorCounterDataAMD(&observer, monitor, pname, dataSize, data, bytesWritten);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfMonitorCounterInfoAMD");
    s->glGetPerfMonitorCounterInfoAMD(&observer, group, counter, pname, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfMonitorCounterStringAMD");
    s->glGetPerfMonitorCounterStringAMD(&observer, group, counter, bufSize, length, counterString);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfMonitorCountersAMD");
    s->glGetPerfMonitorCountersAMD(&observer, group, numCounters, maxActiveCounters, counterSize, counters);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfMonitorGroupStringAMD");
    s->glGetPerfMonitorGroupStringAMD(&observer, group, bufSize, length, groupString);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfMonitorGroupsAMD");
    s->glGetPerfMonitorGroupsAMD(&observer, numGroups, groupsSize, groups);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfQueryDataINTEL");
    s->glGetPerfQueryDataINTEL(&observer, queryHandle, flag, dataSize, data, bytesWritten);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfQueryIdByNameINTEL");
    s->glGetPerfQueryIdByNameINTEL(&observer, queryName, queryId);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetPerfQueryInfoINTEL");
    s->glGetPerfQueryInfoINTEL(&observer, queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramBinaryOES");
    s->glGetProgramBinaryOES(&observer, program, buffer_size, bytes_written, binary_format, binary);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramPipelineInfoLogEXT");
    s->glGetProgramPipelineInfoLogEXT(&observer, pipeline, bufSize, length, infoLog);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramPipelineivEXT");
    s->glGetProgramPipelineivEXT(&observer, pipeline, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramResourceLocationIndexEXT");
    auto _result_ = s->glGetProgramResourceLocationIndexEXT(&observer, program, programInterface, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramResourcefvNV");
    s->glGetProgramResourcefvNV(&observer, program, programInterface, index, propCount, props, bufSize, length, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjecti64vEXT");
    s->glGetQueryObjecti64vEXT(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjectivEXT");
    s->glGetQueryObjectivEXT(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjectui64vEXT");
    s->glGetQueryObjectui64vEXT(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjectuivEXT");
    s->glGetQueryObjectuivEXT(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryivEXT");
    s->glGetQueryivEXT(&observer, target, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterIivOES");
    s->glGetSamplerParameterIivOES(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterIuivOES");
    s->glGetSamplerParameterIuivOES(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSyncivAPPLE");
    s->glGetSyncivAPPLE(&observer, sync, pname, bufSize, length, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterIivOES");
    s->glGetTexParameterIivOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterIuivOES");
    s->glGetTexParameterIuivOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetTexParameterIuivOES() -- done");
}
EXPORT GLuint64 STDCALL glGetTextureHandleNV(TextureId texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTextureHandleNV(%" PRIu32 ")", texture);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTextureHandleNV");
    auto _result_ = s->glGetTextureHandleNV(&observer, texture);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTextureSamplerHandleNV");
    auto _result_ = s->glGetTextureSamplerHandleNV(&observer, texture, sampler);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTranslatedShaderSourceANGLE");
    s->glGetTranslatedShaderSourceANGLE(&observer, shader, bufsize, length, source);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformfvEXT");
    s->glGetnUniformfvEXT(&observer, program, location, bufSize, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformfvKHR");
    s->glGetnUniformfvKHR(&observer, program, location, bufSize, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformivEXT");
    s->glGetnUniformivEXT(&observer, program, location, bufSize, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformivKHR");
    s->glGetnUniformivKHR(&observer, program, location, bufSize, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformuivKHR");
    s->glGetnUniformuivKHR(&observer, program, location, bufSize, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glInsertEventMarkerEXT");
    s->glInsertEventMarkerEXT(&observer, length, marker);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glInterpolatePathsNV");
    s->glInterpolatePathsNV(&observer, resultPath, pathA, pathB, weight);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsEnablediNV");
    auto _result_ = s->glIsEnablediNV(&observer, target, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsEnablediOES");
    auto _result_ = s->glIsEnablediOES(&observer, target, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsEnablediOES() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsFenceNV(GLuint fence) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsFenceNV(%" PRIu32 ")", fence);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsFenceNV");
    auto _result_ = s->glIsFenceNV(&observer, fence);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsFenceNV() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsImageHandleResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsImageHandleResidentNV(%" PRIu64 ")", handle);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsImageHandleResidentNV");
    auto _result_ = s->glIsImageHandleResidentNV(&observer, handle);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsImageHandleResidentNV() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsPathNV(GLuint path) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsPathNV(%" PRIu32 ")", path);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsPathNV");
    auto _result_ = s->glIsPathNV(&observer, path);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsPointInFillPathNV");
    auto _result_ = s->glIsPointInFillPathNV(&observer, path, mask, x, y);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsPointInStrokePathNV");
    auto _result_ = s->glIsPointInStrokePathNV(&observer, path, x, y);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsPointInStrokePathNV() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsProgramPipelineEXT(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsProgramPipelineEXT(%" PRIu32 ")", pipeline);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsProgramPipelineEXT");
    auto _result_ = s->glIsProgramPipelineEXT(&observer, pipeline);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsProgramPipelineEXT() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsQueryEXT(QueryId query) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsQueryEXT(%" PRIu32 ")", query);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsQueryEXT");
    auto _result_ = s->glIsQueryEXT(&observer, query);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsQueryEXT() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsSyncAPPLE(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsSyncAPPLE(%p)", sync);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsSyncAPPLE");
    auto _result_ = s->glIsSyncAPPLE(&observer, sync);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsSyncAPPLE() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsTextureHandleResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsTextureHandleResidentNV(%" PRIu64 ")", handle);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsTextureHandleResidentNV");
    auto _result_ = s->glIsTextureHandleResidentNV(&observer, handle);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsTextureHandleResidentNV() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsVertexArrayOES(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsVertexArrayOES(%" PRIu32 ")", array);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsVertexArrayOES");
    auto _result_ = s->glIsVertexArrayOES(&observer, array);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLabelObjectEXT");
    s->glLabelObjectEXT(&observer, type, object, length, label);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLabelObjectEXT() -- done");
}
EXPORT void STDCALL glMakeImageHandleNonResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeImageHandleNonResidentNV(%" PRIu64 ")", handle);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMakeImageHandleNonResidentNV");
    s->glMakeImageHandleNonResidentNV(&observer, handle);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMakeImageHandleResidentNV");
    s->glMakeImageHandleResidentNV(&observer, handle, access);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMakeImageHandleResidentNV() -- done");
}
EXPORT void STDCALL glMakeTextureHandleNonResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeTextureHandleNonResidentNV(%" PRIu64 ")", handle);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMakeTextureHandleNonResidentNV");
    s->glMakeTextureHandleNonResidentNV(&observer, handle);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMakeTextureHandleNonResidentNV() -- done");
}
EXPORT void STDCALL glMakeTextureHandleResidentNV(GLuint64 handle) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMakeTextureHandleResidentNV(%" PRIu64 ")", handle);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMakeTextureHandleResidentNV");
    s->glMakeTextureHandleResidentNV(&observer, handle);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMapBufferOES");
    auto _result_ = s->glMapBufferOES(&observer, target, access);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMapBufferRangeEXT");
    auto _result_ = s->glMapBufferRangeEXT(&observer, target, offset, length, access);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixLoad3x2fNV");
    s->glMatrixLoad3x2fNV(&observer, matrixMode, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixLoad3x3fNV");
    s->glMatrixLoad3x3fNV(&observer, matrixMode, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixLoadTranspose3x3fNV");
    s->glMatrixLoadTranspose3x3fNV(&observer, matrixMode, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixMult3x2fNV");
    s->glMatrixMult3x2fNV(&observer, matrixMode, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixMult3x3fNV");
    s->glMatrixMult3x3fNV(&observer, matrixMode, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixMultTranspose3x3fNV");
    s->glMatrixMultTranspose3x3fNV(&observer, matrixMode, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiDrawArraysEXT");
    s->glMultiDrawArraysEXT(&observer, mode, first, count, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiDrawArraysIndirectEXT");
    s->glMultiDrawArraysIndirectEXT(&observer, mode, indirect, drawcount, stride);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiDrawElementsBaseVertexEXT");
    s->glMultiDrawElementsBaseVertexEXT(&observer, mode, count, type, indices, primcount, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiDrawElementsBaseVertexOES");
    s->glMultiDrawElementsBaseVertexOES(&observer, mode, count, type, indices, primcount, basevertex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiDrawElementsEXT");
    s->glMultiDrawElementsEXT(&observer, mode, count, type, indices, primcount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiDrawElementsIndirectEXT");
    s->glMultiDrawElementsIndirectEXT(&observer, mode, type, indirect, drawcount, stride);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glNamedFramebufferSampleLocationsfvNV");
    s->glNamedFramebufferSampleLocationsfvNV(&observer, framebuffer, start, count, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPatchParameteriOES");
    s->glPatchParameteriOES(&observer, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathCommandsNV");
    s->glPathCommandsNV(&observer, path, numCommands, commands, numCoords, coordType, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathCoordsNV");
    s->glPathCoordsNV(&observer, path, numCoords, coordType, coords);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPathCoordsNV() -- done");
}
EXPORT void STDCALL glPathCoverDepthFuncNV(uint32_t func) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPathCoverDepthFuncNV(%u)", func);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathCoverDepthFuncNV");
    s->glPathCoverDepthFuncNV(&observer, func);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathDashArrayNV");
    s->glPathDashArrayNV(&observer, path, dashCount, dashArray);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathGlyphIndexArrayNV");
    auto _result_ = s->glPathGlyphIndexArrayNV(&observer, firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathGlyphIndexRangeNV");
    auto _result_ = s->glPathGlyphIndexRangeNV(&observer, fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathGlyphRangeNV");
    s->glPathGlyphRangeNV(&observer, firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathGlyphsNV");
    s->glPathGlyphsNV(&observer, firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathMemoryGlyphIndexArrayNV");
    auto _result_ = s->glPathMemoryGlyphIndexArrayNV(&observer, firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathParameterfNV");
    s->glPathParameterfNV(&observer, path, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathParameterfvNV");
    s->glPathParameterfvNV(&observer, path, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathParameteriNV");
    s->glPathParameteriNV(&observer, path, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathParameterivNV");
    s->glPathParameterivNV(&observer, path, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathStencilDepthOffsetNV");
    s->glPathStencilDepthOffsetNV(&observer, factor, units);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathStencilFuncNV");
    s->glPathStencilFuncNV(&observer, func, ref, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathStringNV");
    s->glPathStringNV(&observer, path, format, length, pathString);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathSubCommandsNV");
    s->glPathSubCommandsNV(&observer, path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPathSubCoordsNV");
    s->glPathSubCoordsNV(&observer, path, coordStart, numCoords, coordType, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointAlongPathNV");
    auto _result_ = s->glPointAlongPathNV(&observer, path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPolygonModeNV");
    s->glPolygonModeNV(&observer, face, mode);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPolygonModeNV() -- done");
}
EXPORT void STDCALL glPopGroupMarkerEXT() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopGroupMarkerEXT()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPopGroupMarkerEXT");
    s->glPopGroupMarkerEXT(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPrimitiveBoundingBoxOES");
    s->glPrimitiveBoundingBoxOES(&observer, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramBinaryOES");
    s->glProgramBinaryOES(&observer, program, binary_format, binary, binary_size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramParameteriEXT");
    s->glProgramParameteriEXT(&observer, program, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramPathFragmentInputGenNV");
    s->glProgramPathFragmentInputGenNV(&observer, program, location, genMode, components, coeffs);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1fEXT");
    s->glProgramUniform1fEXT(&observer, program, location, v0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1fvEXT");
    s->glProgramUniform1fvEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1iEXT");
    s->glProgramUniform1iEXT(&observer, program, location, v0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1ivEXT");
    s->glProgramUniform1ivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1uiEXT");
    s->glProgramUniform1uiEXT(&observer, program, location, v0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1uivEXT");
    s->glProgramUniform1uivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2fEXT");
    s->glProgramUniform2fEXT(&observer, program, location, v0, v1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2fvEXT");
    s->glProgramUniform2fvEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2iEXT");
    s->glProgramUniform2iEXT(&observer, program, location, v0, v1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2ivEXT");
    s->glProgramUniform2ivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2uiEXT");
    s->glProgramUniform2uiEXT(&observer, program, location, v0, v1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2uivEXT");
    s->glProgramUniform2uivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3fEXT");
    s->glProgramUniform3fEXT(&observer, program, location, v0, v1, v2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3fvEXT");
    s->glProgramUniform3fvEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3iEXT");
    s->glProgramUniform3iEXT(&observer, program, location, v0, v1, v2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3ivEXT");
    s->glProgramUniform3ivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3uiEXT");
    s->glProgramUniform3uiEXT(&observer, program, location, v0, v1, v2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3uivEXT");
    s->glProgramUniform3uivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4fEXT");
    s->glProgramUniform4fEXT(&observer, program, location, v0, v1, v2, v3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4fvEXT");
    s->glProgramUniform4fvEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4iEXT");
    s->glProgramUniform4iEXT(&observer, program, location, v0, v1, v2, v3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4ivEXT");
    s->glProgramUniform4ivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4uiEXT");
    s->glProgramUniform4uiEXT(&observer, program, location, v0, v1, v2, v3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4uivEXT");
    s->glProgramUniform4uivEXT(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformHandleui64NV");
    s->glProgramUniformHandleui64NV(&observer, program, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformHandleui64vNV");
    s->glProgramUniformHandleui64vNV(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix2fvEXT");
    s->glProgramUniformMatrix2fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix2x3fvEXT");
    s->glProgramUniformMatrix2x3fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix2x4fvEXT");
    s->glProgramUniformMatrix2x4fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix3fvEXT");
    s->glProgramUniformMatrix3fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix3x2fvEXT");
    s->glProgramUniformMatrix3x2fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix3x4fvEXT");
    s->glProgramUniformMatrix3x4fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix4fvEXT");
    s->glProgramUniformMatrix4fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix4x2fvEXT");
    s->glProgramUniformMatrix4x2fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix4x3fvEXT");
    s->glProgramUniformMatrix4x3fvEXT(&observer, program, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPushGroupMarkerEXT");
    s->glPushGroupMarkerEXT(&observer, length, marker);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glQueryCounterEXT");
    s->glQueryCounterEXT(&observer, query, target);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRasterSamplesEXT");
    s->glRasterSamplesEXT(&observer, samples, fixedsamplelocations);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadBufferIndexedEXT");
    s->glReadBufferIndexedEXT(&observer, src, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glReadBufferIndexedEXT() -- done");
}
EXPORT void STDCALL glReadBufferNV(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadBufferNV(%u)", mode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadBufferNV");
    s->glReadBufferNV(&observer, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadnPixelsEXT");
    s->glReadnPixelsEXT(&observer, x, y, width, height, format, type, bufSize, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadnPixelsKHR");
    s->glReadnPixelsKHR(&observer, x, y, width, height, format, type, bufSize, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageMultisampleANGLE");
    s->glRenderbufferStorageMultisampleANGLE(&observer, target, samples, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageMultisampleAPPLE");
    s->glRenderbufferStorageMultisampleAPPLE(&observer, target, samples, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageMultisampleEXT");
    s->glRenderbufferStorageMultisampleEXT(&observer, target, samples, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageMultisampleIMG");
    s->glRenderbufferStorageMultisampleIMG(&observer, target, samples, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageMultisampleNV");
    s->glRenderbufferStorageMultisampleNV(&observer, target, samples, internalformat, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glRenderbufferStorageMultisampleNV() -- done");
}
EXPORT void STDCALL glResolveDepthValuesNV() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glResolveDepthValuesNV()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glResolveDepthValuesNV");
    s->glResolveDepthValuesNV(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glResolveDepthValuesNV() -- done");
}
EXPORT void STDCALL glResolveMultisampleFramebufferAPPLE() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glResolveMultisampleFramebufferAPPLE()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glResolveMultisampleFramebufferAPPLE");
    s->glResolveMultisampleFramebufferAPPLE(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterIivOES");
    s->glSamplerParameterIivOES(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterIuivOES");
    s->glSamplerParameterIuivOES(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissorArrayvNV");
    s->glScissorArrayvNV(&observer, first, count, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissorIndexedNV");
    s->glScissorIndexedNV(&observer, index, left, bottom, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissorIndexedvNV");
    s->glScissorIndexedvNV(&observer, index, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSelectPerfMonitorCountersAMD");
    s->glSelectPerfMonitorCountersAMD(&observer, monitor, enable, group, numCounters, counterList);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSetFenceNV");
    s->glSetFenceNV(&observer, fence, condition);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStartTilingQCOM");
    s->glStartTilingQCOM(&observer, x, y, width, height, preserveMask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilFillPathInstancedNV");
    s->glStencilFillPathInstancedNV(&observer, numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilFillPathNV");
    s->glStencilFillPathNV(&observer, path, fillMode, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilStrokePathInstancedNV");
    s->glStencilStrokePathInstancedNV(&observer, numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilStrokePathNV");
    s->glStencilStrokePathNV(&observer, path, reference, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilThenCoverFillPathInstancedNV");
    s->glStencilThenCoverFillPathInstancedNV(&observer, numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilThenCoverFillPathNV");
    s->glStencilThenCoverFillPathNV(&observer, path, fillMode, mask, coverMode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilThenCoverStrokePathInstancedNV");
    s->glStencilThenCoverStrokePathInstancedNV(&observer, numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilThenCoverStrokePathNV");
    s->glStencilThenCoverStrokePathNV(&observer, path, reference, mask, coverMode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSubpixelPrecisionBiasNV");
    s->glSubpixelPrecisionBiasNV(&observer, xbits, ybits);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glSubpixelPrecisionBiasNV() -- done");
}
EXPORT GLboolean STDCALL glTestFenceNV(GLuint fence) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTestFenceNV(%" PRIu32 ")", fence);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTestFenceNV");
    auto _result_ = s->glTestFenceNV(&observer, fence);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexBufferOES");
    s->glTexBufferOES(&observer, target, internalformat, buffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexBufferRangeOES");
    s->glTexBufferRangeOES(&observer, target, internalformat, buffer, offset, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexImage3DOES");
    s->glTexImage3DOES(&observer, target, level, internalformat, width, height, depth, border, format, type, pixels);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexPageCommitmentEXT");
    s->glTexPageCommitmentEXT(&observer, target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterIivOES");
    s->glTexParameterIivOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterIuivOES");
    s->glTexParameterIuivOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexParameterIuivOES() -- done");
}
EXPORT void STDCALL glTexStorage1DEXT(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage1DEXT(%u, %" PRId32 ", %u, %" PRId32 ")", target, levels, internalformat, width);
    if (!s->try_to_enter()) {
        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, internalformat, width);
        GAPID_DEBUG("glTexStorage1DEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage1DEXT");
    s->glTexStorage1DEXT(&observer, target, levels, internalformat, width);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexStorage1DEXT() -- done");
}
EXPORT void STDCALL glTexStorage2DEXT(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage2DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, levels, internalformat, width, height);
    if (!s->try_to_enter()) {
        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, internalformat, width, height);
        GAPID_DEBUG("glTexStorage2DEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage2DEXT");
    s->glTexStorage2DEXT(&observer, target, levels, internalformat, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexStorage2DEXT() -- done");
}
EXPORT void STDCALL glTexStorage3DEXT(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage3DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, levels, internalformat, width, height, depth);
    if (!s->try_to_enter()) {
        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, internalformat, width, height, depth);
        GAPID_DEBUG("glTexStorage3DEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage3DEXT");
    s->glTexStorage3DEXT(&observer, target, levels, internalformat, width, height, depth);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexSubImage3DOES");
    s->glTexSubImage3DOES(&observer, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexSubImage3DOES() -- done");
}
EXPORT void STDCALL glTextureStorage1DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureStorage1DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ")", texture, target, levels, internalformat, width);
    if (!s->try_to_enter()) {
        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, internalformat, width);
        GAPID_DEBUG("glTextureStorage1DEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTextureStorage1DEXT");
    s->glTextureStorage1DEXT(&observer, texture, target, levels, internalformat, width);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTextureStorage1DEXT() -- done");
}
EXPORT void STDCALL glTextureStorage2DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureStorage2DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", texture, target, levels, internalformat, width, height);
    if (!s->try_to_enter()) {
        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, internalformat, width, height);
        GAPID_DEBUG("glTextureStorage2DEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTextureStorage2DEXT");
    s->glTextureStorage2DEXT(&observer, texture, target, levels, internalformat, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTextureStorage2DEXT() -- done");
}
EXPORT void STDCALL glTextureStorage3DEXT(TextureId texture, uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width, GLsizei height, GLsizei depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTextureStorage3DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, target, levels, internalformat, width, height, depth);
    if (!s->try_to_enter()) {
        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, internalformat, width, height, depth);
        GAPID_DEBUG("glTextureStorage3DEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTextureStorage3DEXT");
    s->glTextureStorage3DEXT(&observer, texture, target, levels, internalformat, width, height, depth);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTextureViewEXT");
    s->glTextureViewEXT(&observer, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTextureViewOES");
    s->glTextureViewOES(&observer, texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTransformPathNV");
    s->glTransformPathNV(&observer, resultPath, srcPath, transformType, transformValues);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformHandleui64NV");
    s->glUniformHandleui64NV(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformHandleui64vNV");
    s->glUniformHandleui64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix2x3fvNV");
    s->glUniformMatrix2x3fvNV(&observer, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix2x4fvNV");
    s->glUniformMatrix2x4fvNV(&observer, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix3x2fvNV");
    s->glUniformMatrix3x2fvNV(&observer, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix3x4fvNV");
    s->glUniformMatrix3x4fvNV(&observer, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix4x2fvNV");
    s->glUniformMatrix4x2fvNV(&observer, location, count, transpose, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix4x3fvNV");
    s->glUniformMatrix4x3fvNV(&observer, location, count, transpose, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniformMatrix4x3fvNV() -- done");
}
EXPORT GLboolean STDCALL glUnmapBufferOES(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUnmapBufferOES(%u)", target);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUnmapBufferOES");
    auto _result_ = s->glUnmapBufferOES(&observer, target);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUseProgramStagesEXT");
    s->glUseProgramStagesEXT(&observer, pipeline, stages, program);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUseProgramStagesEXT() -- done");
}
EXPORT void STDCALL glValidateProgramPipelineEXT(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glValidateProgramPipelineEXT(%" PRIu32 ")", pipeline);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glValidateProgramPipelineEXT");
    s->glValidateProgramPipelineEXT(&observer, pipeline);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribDivisorANGLE");
    s->glVertexAttribDivisorANGLE(&observer, index, divisor);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribDivisorEXT");
    s->glVertexAttribDivisorEXT(&observer, index, divisor);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribDivisorNV");
    s->glVertexAttribDivisorNV(&observer, index, divisor);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportArrayvNV");
    s->glViewportArrayvNV(&observer, first, count, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportIndexedfNV");
    s->glViewportIndexedfNV(&observer, index, x, y, w, h);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportIndexedfvNV");
    s->glViewportIndexedfvNV(&observer, index, v);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glWaitSyncAPPLE");
    s->glWaitSyncAPPLE(&observer, sync, flag, timeout);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glWeightPathsNV");
    s->glWeightPathsNV(&observer, resultPath, numPaths, paths, weights);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glWeightPathsNV() -- done");
}
EXPORT void STDCALL glClearPixelLocalStorageuiEXT(GLsizei offset, GLsizei n, GLuint* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearPixelLocalStorageuiEXT(%" PRId32 ", %" PRId32 ", %p)", offset, n, values);
    if (!s->try_to_enter()) {
        GAPID_INFO("glClearPixelLocalStorageuiEXT at %p: GAPII re-entered. Just invoking imported function at %p", glClearPixelLocalStorageuiEXT, s->GlesSpy::imports().glClearPixelLocalStorageuiEXT);
        s->GlesSpy::imports().glClearPixelLocalStorageuiEXT(offset, n, values);
        GAPID_DEBUG("glClearPixelLocalStorageuiEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearPixelLocalStorageuiEXT");
    s->glClearPixelLocalStorageuiEXT(&observer, offset, n, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearPixelLocalStorageuiEXT() -- done");
}
EXPORT void STDCALL glClearTexImageEXT(GLuint texture, GLint level, uint32_t format, uint32_t type, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearTexImageEXT(%" PRIu32 ", %" PRId32 ", %u, %u, %p)", texture, level, format, type, data);
    if (!s->try_to_enter()) {
        GAPID_INFO("glClearTexImageEXT at %p: GAPII re-entered. Just invoking imported function at %p", glClearTexImageEXT, s->GlesSpy::imports().glClearTexImageEXT);
        s->GlesSpy::imports().glClearTexImageEXT(texture, level, format, type, data);
        GAPID_DEBUG("glClearTexImageEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearTexImageEXT");
    s->glClearTexImageEXT(&observer, texture, level, format, type, data);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearTexImageEXT() -- done");
}
EXPORT void STDCALL glClearTexSubImageEXT(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, uint32_t format, uint32_t type, void* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearTexSubImageEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
    if (!s->try_to_enter()) {
        GAPID_INFO("glClearTexSubImageEXT at %p: GAPII re-entered. Just invoking imported function at %p", glClearTexSubImageEXT, s->GlesSpy::imports().glClearTexSubImageEXT);
        s->GlesSpy::imports().glClearTexSubImageEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
        GAPID_DEBUG("glClearTexSubImageEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearTexSubImageEXT");
    s->glClearTexSubImageEXT(&observer, texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearTexSubImageEXT() -- done");
}
EXPORT void STDCALL glConservativeRasterParameteriNV(uint32_t pname, GLint param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glConservativeRasterParameteriNV(%u, %" PRId32 ")", pname, param);
    if (!s->try_to_enter()) {
        GAPID_INFO("glConservativeRasterParameteriNV at %p: GAPII re-entered. Just invoking imported function at %p", glConservativeRasterParameteriNV, s->GlesSpy::imports().glConservativeRasterParameteriNV);
        s->GlesSpy::imports().glConservativeRasterParameteriNV(pname, param);
        GAPID_DEBUG("glConservativeRasterParameteriNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glConservativeRasterParameteriNV");
    s->glConservativeRasterParameteriNV(&observer, pname, param);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glConservativeRasterParameteriNV() -- done");
}
EXPORT void STDCALL glDepthRangeArrayfvOES(GLuint first, GLsizei count, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangeArrayfvOES(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
    if (!s->try_to_enter()) {
        GAPID_INFO("glDepthRangeArrayfvOES at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangeArrayfvOES, s->GlesSpy::imports().glDepthRangeArrayfvOES);
        s->GlesSpy::imports().glDepthRangeArrayfvOES(first, count, v);
        GAPID_DEBUG("glDepthRangeArrayfvOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangeArrayfvOES");
    s->glDepthRangeArrayfvOES(&observer, first, count, v);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDepthRangeArrayfvOES() -- done");
}
EXPORT void STDCALL glDepthRangeIndexedfOES(GLuint index, GLfloat n, GLfloat f) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthRangeIndexedfOES(%" PRIu32 ", %f, %f)", index, n, f);
    if (!s->try_to_enter()) {
        GAPID_INFO("glDepthRangeIndexedfOES at %p: GAPII re-entered. Just invoking imported function at %p", glDepthRangeIndexedfOES, s->GlesSpy::imports().glDepthRangeIndexedfOES);
        s->GlesSpy::imports().glDepthRangeIndexedfOES(index, n, f);
        GAPID_DEBUG("glDepthRangeIndexedfOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangeIndexedfOES");
    s->glDepthRangeIndexedfOES(&observer, index, n, f);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDepthRangeIndexedfOES() -- done");
}
EXPORT void STDCALL glDrawTransformFeedbackEXT(uint32_t mode, GLuint id) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTransformFeedbackEXT(%u, %" PRIu32 ")", mode, id);
    if (!s->try_to_enter()) {
        GAPID_INFO("glDrawTransformFeedbackEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTransformFeedbackEXT, s->GlesSpy::imports().glDrawTransformFeedbackEXT);
        s->GlesSpy::imports().glDrawTransformFeedbackEXT(mode, id);
        GAPID_DEBUG("glDrawTransformFeedbackEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTransformFeedbackEXT");
    s->glDrawTransformFeedbackEXT(&observer, mode, id);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTransformFeedbackEXT() -- done");
}
EXPORT void STDCALL glDrawTransformFeedbackInstancedEXT(uint32_t mode, GLuint id, GLsizei instancecount) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTransformFeedbackInstancedEXT(%u, %" PRIu32 ", %" PRId32 ")", mode, id, instancecount);
    if (!s->try_to_enter()) {
        GAPID_INFO("glDrawTransformFeedbackInstancedEXT at %p: GAPII re-entered. Just invoking imported function at %p", glDrawTransformFeedbackInstancedEXT, s->GlesSpy::imports().glDrawTransformFeedbackInstancedEXT);
        s->GlesSpy::imports().glDrawTransformFeedbackInstancedEXT(mode, id, instancecount);
        GAPID_DEBUG("glDrawTransformFeedbackInstancedEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTransformFeedbackInstancedEXT");
    s->glDrawTransformFeedbackInstancedEXT(&observer, mode, id, instancecount);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTransformFeedbackInstancedEXT() -- done");
}
EXPORT void STDCALL glFramebufferPixelLocalStorageSizeEXT(GLuint target, GLsizei size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferPixelLocalStorageSizeEXT(%" PRIu32 ", %" PRId32 ")", target, size);
    if (!s->try_to_enter()) {
        GAPID_INFO("glFramebufferPixelLocalStorageSizeEXT at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferPixelLocalStorageSizeEXT, s->GlesSpy::imports().glFramebufferPixelLocalStorageSizeEXT);
        s->GlesSpy::imports().glFramebufferPixelLocalStorageSizeEXT(target, size);
        GAPID_DEBUG("glFramebufferPixelLocalStorageSizeEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferPixelLocalStorageSizeEXT");
    s->glFramebufferPixelLocalStorageSizeEXT(&observer, target, size);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFramebufferPixelLocalStorageSizeEXT() -- done");
}
EXPORT void STDCALL glFramebufferTexture2DDownsampleIMG(uint32_t target, uint32_t attachment, uint32_t textarget, GLuint texture, GLint level, GLint xscale, GLint yscale) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTexture2DDownsampleIMG(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, xscale, yscale);
    if (!s->try_to_enter()) {
        GAPID_INFO("glFramebufferTexture2DDownsampleIMG at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTexture2DDownsampleIMG, s->GlesSpy::imports().glFramebufferTexture2DDownsampleIMG);
        s->GlesSpy::imports().glFramebufferTexture2DDownsampleIMG(target, attachment, textarget, texture, level, xscale, yscale);
        GAPID_DEBUG("glFramebufferTexture2DDownsampleIMG() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture2DDownsampleIMG");
    s->glFramebufferTexture2DDownsampleIMG(&observer, target, attachment, textarget, texture, level, xscale, yscale);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFramebufferTexture2DDownsampleIMG() -- done");
}
EXPORT void STDCALL glFramebufferTextureLayerDownsampleIMG(uint32_t target, uint32_t attachment, GLuint texture, GLint level, GLint layer, GLint xscale, GLint yscale) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTextureLayerDownsampleIMG(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, layer, xscale, yscale);
    if (!s->try_to_enter()) {
        GAPID_INFO("glFramebufferTextureLayerDownsampleIMG at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTextureLayerDownsampleIMG, s->GlesSpy::imports().glFramebufferTextureLayerDownsampleIMG);
        s->GlesSpy::imports().glFramebufferTextureLayerDownsampleIMG(target, attachment, texture, level, layer, xscale, yscale);
        GAPID_DEBUG("glFramebufferTextureLayerDownsampleIMG() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTextureLayerDownsampleIMG");
    s->glFramebufferTextureLayerDownsampleIMG(&observer, target, attachment, texture, level, layer, xscale, yscale);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFramebufferTextureLayerDownsampleIMG() -- done");
}
EXPORT void STDCALL glFramebufferTextureMultisampleMultiviewOVR(uint32_t target, uint32_t attachment, GLuint texture, GLint level, GLsizei samples, GLint baseViewIndex, GLsizei numViews) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFramebufferTextureMultisampleMultiviewOVR(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, samples, baseViewIndex, numViews);
    if (!s->try_to_enter()) {
        GAPID_INFO("glFramebufferTextureMultisampleMultiviewOVR at %p: GAPII re-entered. Just invoking imported function at %p", glFramebufferTextureMultisampleMultiviewOVR, s->GlesSpy::imports().glFramebufferTextureMultisampleMultiviewOVR);
        s->GlesSpy::imports().glFramebufferTextureMultisampleMultiviewOVR(target, attachment, texture, level, samples, baseViewIndex, numViews);
        GAPID_DEBUG("glFramebufferTextureMultisampleMultiviewOVR() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTextureMultisampleMultiviewOVR");
    s->glFramebufferTextureMultisampleMultiviewOVR(&observer, target, attachment, texture, level, samples, baseViewIndex, numViews);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFramebufferTextureMultisampleMultiviewOVR() -- done");
}
EXPORT void STDCALL glGetFloati_vOES(uint32_t target, GLuint index, GLfloat* data) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFloati_vOES(%u, %" PRIu32 ", %p)", target, index, data);
    if (!s->try_to_enter()) {
        GAPID_INFO("glGetFloati_vOES at %p: GAPII re-entered. Just invoking imported function at %p", glGetFloati_vOES, s->GlesSpy::imports().glGetFloati_vOES);
        s->GlesSpy::imports().glGetFloati_vOES(target, index, data);
        GAPID_DEBUG("glGetFloati_vOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFloati_vOES");
    s->glGetFloati_vOES(&observer, target, index, data);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetFloati_vOES() -- done");
}
EXPORT GLsizei STDCALL glGetFramebufferPixelLocalStorageSizeEXT(GLuint target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetFramebufferPixelLocalStorageSizeEXT(%" PRIu32 ")", target);
    if (!s->try_to_enter()) {
        GAPID_INFO("glGetFramebufferPixelLocalStorageSizeEXT at %p: GAPII re-entered. Just invoking imported function at %p", glGetFramebufferPixelLocalStorageSizeEXT, s->GlesSpy::imports().glGetFramebufferPixelLocalStorageSizeEXT);
        auto _result_ = s->GlesSpy::imports().glGetFramebufferPixelLocalStorageSizeEXT(target);
        GAPID_DEBUG("glGetFramebufferPixelLocalStorageSizeEXT() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFramebufferPixelLocalStorageSizeEXT");
    auto _result_ = s->glGetFramebufferPixelLocalStorageSizeEXT(&observer, target);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetFramebufferPixelLocalStorageSizeEXT() -- done");
    return _result_;
}
EXPORT GLuint64 STDCALL glGetTextureHandleIMG(GLuint texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTextureHandleIMG(%" PRIu32 ")", texture);
    if (!s->try_to_enter()) {
        GAPID_INFO("glGetTextureHandleIMG at %p: GAPII re-entered. Just invoking imported function at %p", glGetTextureHandleIMG, s->GlesSpy::imports().glGetTextureHandleIMG);
        auto _result_ = s->GlesSpy::imports().glGetTextureHandleIMG(texture);
        GAPID_DEBUG("glGetTextureHandleIMG() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTextureHandleIMG");
    auto _result_ = s->glGetTextureHandleIMG(&observer, texture);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetTextureHandleIMG() -- done");
    return _result_;
}
EXPORT GLuint64 STDCALL glGetTextureSamplerHandleIMG(GLuint texture, GLuint sampler) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetTextureSamplerHandleIMG(%" PRIu32 ", %" PRIu32 ")", texture, sampler);
    if (!s->try_to_enter()) {
        GAPID_INFO("glGetTextureSamplerHandleIMG at %p: GAPII re-entered. Just invoking imported function at %p", glGetTextureSamplerHandleIMG, s->GlesSpy::imports().glGetTextureSamplerHandleIMG);
        auto _result_ = s->GlesSpy::imports().glGetTextureSamplerHandleIMG(texture, sampler);
        GAPID_DEBUG("glGetTextureSamplerHandleIMG() -- done");
        return _result_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTextureSamplerHandleIMG");
    auto _result_ = s->glGetTextureSamplerHandleIMG(&observer, texture, sampler);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetTextureSamplerHandleIMG() -- done");
    return _result_;
}
EXPORT void STDCALL glGetUniformi64vNV(GLuint program, GLint location, GLint64EXT* params) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetUniformi64vNV(%" PRIu32 ", %" PRId32 ", %p)", program, location, params);
    if (!s->try_to_enter()) {
        GAPID_INFO("glGetUniformi64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glGetUniformi64vNV, s->GlesSpy::imports().glGetUniformi64vNV);
        s->GlesSpy::imports().glGetUniformi64vNV(program, location, params);
        GAPID_DEBUG("glGetUniformi64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformi64vNV");
    s->glGetUniformi64vNV(&observer, program, location, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetUniformi64vNV() -- done");
}
EXPORT void STDCALL glPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPolygonOffsetClampEXT(%f, %f, %f)", factor, units, clamp);
    if (!s->try_to_enter()) {
        GAPID_INFO("glPolygonOffsetClampEXT at %p: GAPII re-entered. Just invoking imported function at %p", glPolygonOffsetClampEXT, s->GlesSpy::imports().glPolygonOffsetClampEXT);
        s->GlesSpy::imports().glPolygonOffsetClampEXT(factor, units, clamp);
        GAPID_DEBUG("glPolygonOffsetClampEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPolygonOffsetClampEXT");
    s->glPolygonOffsetClampEXT(&observer, factor, units, clamp);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPolygonOffsetClampEXT() -- done");
}
EXPORT void STDCALL glProgramUniform1i64NV(GLuint program, GLint location, GLint64EXT x) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1i64NV(%" PRIu32 ", %" PRId32 ", %" PRId64 ")", program, location, x);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform1i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1i64NV, s->GlesSpy::imports().glProgramUniform1i64NV);
        s->GlesSpy::imports().glProgramUniform1i64NV(program, location, x);
        GAPID_DEBUG("glProgramUniform1i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1i64NV");
    s->glProgramUniform1i64NV(&observer, program, location, x);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform1i64NV() -- done");
}
EXPORT void STDCALL glProgramUniform1i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1i64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform1i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1i64vNV, s->GlesSpy::imports().glProgramUniform1i64vNV);
        s->GlesSpy::imports().glProgramUniform1i64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform1i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1i64vNV");
    s->glProgramUniform1i64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform1i64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform1ui64NV(GLuint program, GLint location, GLuint64EXT x) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1ui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ")", program, location, x);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform1ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1ui64NV, s->GlesSpy::imports().glProgramUniform1ui64NV);
        s->GlesSpy::imports().glProgramUniform1ui64NV(program, location, x);
        GAPID_DEBUG("glProgramUniform1ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1ui64NV");
    s->glProgramUniform1ui64NV(&observer, program, location, x);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform1ui64NV() -- done");
}
EXPORT void STDCALL glProgramUniform1ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform1ui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform1ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform1ui64vNV, s->GlesSpy::imports().glProgramUniform1ui64vNV);
        s->GlesSpy::imports().glProgramUniform1ui64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform1ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1ui64vNV");
    s->glProgramUniform1ui64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform1ui64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform2i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2i64NV(%" PRIu32 ", %" PRId32 ", %" PRId64 ", %" PRId64 ")", program, location, x, y);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform2i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2i64NV, s->GlesSpy::imports().glProgramUniform2i64NV);
        s->GlesSpy::imports().glProgramUniform2i64NV(program, location, x, y);
        GAPID_DEBUG("glProgramUniform2i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2i64NV");
    s->glProgramUniform2i64NV(&observer, program, location, x, y);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform2i64NV() -- done");
}
EXPORT void STDCALL glProgramUniform2i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2i64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform2i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2i64vNV, s->GlesSpy::imports().glProgramUniform2i64vNV);
        s->GlesSpy::imports().glProgramUniform2i64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform2i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2i64vNV");
    s->glProgramUniform2i64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform2i64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform2ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2ui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform2ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2ui64NV, s->GlesSpy::imports().glProgramUniform2ui64NV);
        s->GlesSpy::imports().glProgramUniform2ui64NV(program, location, x, y);
        GAPID_DEBUG("glProgramUniform2ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2ui64NV");
    s->glProgramUniform2ui64NV(&observer, program, location, x, y);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform2ui64NV() -- done");
}
EXPORT void STDCALL glProgramUniform2ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform2ui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform2ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform2ui64vNV, s->GlesSpy::imports().glProgramUniform2ui64vNV);
        s->GlesSpy::imports().glProgramUniform2ui64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform2ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2ui64vNV");
    s->glProgramUniform2ui64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform2ui64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform3i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3i64NV(%" PRIu32 ", %" PRId32 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform3i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3i64NV, s->GlesSpy::imports().glProgramUniform3i64NV);
        s->GlesSpy::imports().glProgramUniform3i64NV(program, location, x, y, z);
        GAPID_DEBUG("glProgramUniform3i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3i64NV");
    s->glProgramUniform3i64NV(&observer, program, location, x, y, z);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform3i64NV() -- done");
}
EXPORT void STDCALL glProgramUniform3i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3i64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform3i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3i64vNV, s->GlesSpy::imports().glProgramUniform3i64vNV);
        s->GlesSpy::imports().glProgramUniform3i64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform3i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3i64vNV");
    s->glProgramUniform3i64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform3i64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform3ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3ui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y, z);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform3ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3ui64NV, s->GlesSpy::imports().glProgramUniform3ui64NV);
        s->GlesSpy::imports().glProgramUniform3ui64NV(program, location, x, y, z);
        GAPID_DEBUG("glProgramUniform3ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3ui64NV");
    s->glProgramUniform3ui64NV(&observer, program, location, x, y, z);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform3ui64NV() -- done");
}
EXPORT void STDCALL glProgramUniform3ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform3ui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform3ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform3ui64vNV, s->GlesSpy::imports().glProgramUniform3ui64vNV);
        s->GlesSpy::imports().glProgramUniform3ui64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform3ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3ui64vNV");
    s->glProgramUniform3ui64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform3ui64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform4i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4i64NV(%" PRIu32 ", %" PRId32 ", %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z, w);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform4i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4i64NV, s->GlesSpy::imports().glProgramUniform4i64NV);
        s->GlesSpy::imports().glProgramUniform4i64NV(program, location, x, y, z, w);
        GAPID_DEBUG("glProgramUniform4i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4i64NV");
    s->glProgramUniform4i64NV(&observer, program, location, x, y, z, w);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform4i64NV() -- done");
}
EXPORT void STDCALL glProgramUniform4i64vNV(GLuint program, GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4i64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform4i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4i64vNV, s->GlesSpy::imports().glProgramUniform4i64vNV);
        s->GlesSpy::imports().glProgramUniform4i64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform4i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4i64vNV");
    s->glProgramUniform4i64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform4i64vNV() -- done");
}
EXPORT void STDCALL glProgramUniform4ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4ui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y, z, w);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform4ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4ui64NV, s->GlesSpy::imports().glProgramUniform4ui64NV);
        s->GlesSpy::imports().glProgramUniform4ui64NV(program, location, x, y, z, w);
        GAPID_DEBUG("glProgramUniform4ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4ui64NV");
    s->glProgramUniform4ui64NV(&observer, program, location, x, y, z, w);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform4ui64NV() -- done");
}
EXPORT void STDCALL glProgramUniform4ui64vNV(GLuint program, GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniform4ui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniform4ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniform4ui64vNV, s->GlesSpy::imports().glProgramUniform4ui64vNV);
        s->GlesSpy::imports().glProgramUniform4ui64vNV(program, location, count, value);
        GAPID_DEBUG("glProgramUniform4ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4ui64vNV");
    s->glProgramUniform4ui64vNV(&observer, program, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniform4ui64vNV() -- done");
}
EXPORT void STDCALL glProgramUniformHandleui64IMG(GLuint program, GLint location, GLuint64 value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformHandleui64IMG(%" PRIu32 ", %" PRId32 ", %" PRIu64 ")", program, location, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniformHandleui64IMG at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformHandleui64IMG, s->GlesSpy::imports().glProgramUniformHandleui64IMG);
        s->GlesSpy::imports().glProgramUniformHandleui64IMG(program, location, value);
        GAPID_DEBUG("glProgramUniformHandleui64IMG() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformHandleui64IMG");
    s->glProgramUniformHandleui64IMG(&observer, program, location, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniformHandleui64IMG() -- done");
}
EXPORT void STDCALL glProgramUniformHandleui64vIMG(GLuint program, GLint location, GLsizei count, GLuint64* values) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glProgramUniformHandleui64vIMG(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
    if (!s->try_to_enter()) {
        GAPID_INFO("glProgramUniformHandleui64vIMG at %p: GAPII re-entered. Just invoking imported function at %p", glProgramUniformHandleui64vIMG, s->GlesSpy::imports().glProgramUniformHandleui64vIMG);
        s->GlesSpy::imports().glProgramUniformHandleui64vIMG(program, location, count, values);
        GAPID_DEBUG("glProgramUniformHandleui64vIMG() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformHandleui64vIMG");
    s->glProgramUniformHandleui64vIMG(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniformHandleui64vIMG() -- done");
}
EXPORT void STDCALL glScissorArrayvOES(GLuint first, GLsizei count, GLint* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissorArrayvOES(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
    if (!s->try_to_enter()) {
        GAPID_INFO("glScissorArrayvOES at %p: GAPII re-entered. Just invoking imported function at %p", glScissorArrayvOES, s->GlesSpy::imports().glScissorArrayvOES);
        s->GlesSpy::imports().glScissorArrayvOES(first, count, v);
        GAPID_DEBUG("glScissorArrayvOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissorArrayvOES");
    s->glScissorArrayvOES(&observer, first, count, v);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glScissorArrayvOES() -- done");
}
EXPORT void STDCALL glScissorIndexedOES(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissorIndexedOES(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", index, left, bottom, width, height);
    if (!s->try_to_enter()) {
        GAPID_INFO("glScissorIndexedOES at %p: GAPII re-entered. Just invoking imported function at %p", glScissorIndexedOES, s->GlesSpy::imports().glScissorIndexedOES);
        s->GlesSpy::imports().glScissorIndexedOES(index, left, bottom, width, height);
        GAPID_DEBUG("glScissorIndexedOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissorIndexedOES");
    s->glScissorIndexedOES(&observer, index, left, bottom, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glScissorIndexedOES() -- done");
}
EXPORT void STDCALL glScissorIndexedvOES(GLuint index, GLint* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glScissorIndexedvOES(%" PRIu32 ", %p)", index, v);
    if (!s->try_to_enter()) {
        GAPID_INFO("glScissorIndexedvOES at %p: GAPII re-entered. Just invoking imported function at %p", glScissorIndexedvOES, s->GlesSpy::imports().glScissorIndexedvOES);
        s->GlesSpy::imports().glScissorIndexedvOES(index, v);
        GAPID_DEBUG("glScissorIndexedvOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissorIndexedvOES");
    s->glScissorIndexedvOES(&observer, index, v);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glScissorIndexedvOES() -- done");
}
EXPORT void STDCALL glUniform1i64NV(GLint location, GLint64EXT x) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1i64NV(%" PRId32 ", %" PRId64 ")", location, x);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform1i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1i64NV, s->GlesSpy::imports().glUniform1i64NV);
        s->GlesSpy::imports().glUniform1i64NV(location, x);
        GAPID_DEBUG("glUniform1i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1i64NV");
    s->glUniform1i64NV(&observer, location, x);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform1i64NV() -- done");
}
EXPORT void STDCALL glUniform1i64vNV(GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1i64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform1i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1i64vNV, s->GlesSpy::imports().glUniform1i64vNV);
        s->GlesSpy::imports().glUniform1i64vNV(location, count, value);
        GAPID_DEBUG("glUniform1i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1i64vNV");
    s->glUniform1i64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform1i64vNV() -- done");
}
EXPORT void STDCALL glUniform1ui64NV(GLint location, GLuint64EXT x) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1ui64NV(%" PRId32 ", %" PRIu64 ")", location, x);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform1ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1ui64NV, s->GlesSpy::imports().glUniform1ui64NV);
        s->GlesSpy::imports().glUniform1ui64NV(location, x);
        GAPID_DEBUG("glUniform1ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1ui64NV");
    s->glUniform1ui64NV(&observer, location, x);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform1ui64NV() -- done");
}
EXPORT void STDCALL glUniform1ui64vNV(GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform1ui64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform1ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform1ui64vNV, s->GlesSpy::imports().glUniform1ui64vNV);
        s->GlesSpy::imports().glUniform1ui64vNV(location, count, value);
        GAPID_DEBUG("glUniform1ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1ui64vNV");
    s->glUniform1ui64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform1ui64vNV() -- done");
}
EXPORT void STDCALL glUniform2i64NV(GLint location, GLint64EXT x, GLint64EXT y) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2i64NV(%" PRId32 ", %" PRId64 ", %" PRId64 ")", location, x, y);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform2i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2i64NV, s->GlesSpy::imports().glUniform2i64NV);
        s->GlesSpy::imports().glUniform2i64NV(location, x, y);
        GAPID_DEBUG("glUniform2i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2i64NV");
    s->glUniform2i64NV(&observer, location, x, y);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform2i64NV() -- done");
}
EXPORT void STDCALL glUniform2i64vNV(GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2i64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform2i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2i64vNV, s->GlesSpy::imports().glUniform2i64vNV);
        s->GlesSpy::imports().glUniform2i64vNV(location, count, value);
        GAPID_DEBUG("glUniform2i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2i64vNV");
    s->glUniform2i64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform2i64vNV() -- done");
}
EXPORT void STDCALL glUniform2ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2ui64NV(%" PRId32 ", %" PRIu64 ", %" PRIu64 ")", location, x, y);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform2ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2ui64NV, s->GlesSpy::imports().glUniform2ui64NV);
        s->GlesSpy::imports().glUniform2ui64NV(location, x, y);
        GAPID_DEBUG("glUniform2ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2ui64NV");
    s->glUniform2ui64NV(&observer, location, x, y);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform2ui64NV() -- done");
}
EXPORT void STDCALL glUniform2ui64vNV(GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform2ui64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform2ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform2ui64vNV, s->GlesSpy::imports().glUniform2ui64vNV);
        s->GlesSpy::imports().glUniform2ui64vNV(location, count, value);
        GAPID_DEBUG("glUniform2ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2ui64vNV");
    s->glUniform2ui64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform2ui64vNV() -- done");
}
EXPORT void STDCALL glUniform3i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3i64NV(%" PRId32 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform3i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3i64NV, s->GlesSpy::imports().glUniform3i64NV);
        s->GlesSpy::imports().glUniform3i64NV(location, x, y, z);
        GAPID_DEBUG("glUniform3i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3i64NV");
    s->glUniform3i64NV(&observer, location, x, y, z);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform3i64NV() -- done");
}
EXPORT void STDCALL glUniform3i64vNV(GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3i64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform3i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3i64vNV, s->GlesSpy::imports().glUniform3i64vNV);
        s->GlesSpy::imports().glUniform3i64vNV(location, count, value);
        GAPID_DEBUG("glUniform3i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3i64vNV");
    s->glUniform3i64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform3i64vNV() -- done");
}
EXPORT void STDCALL glUniform3ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3ui64NV(%" PRId32 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", location, x, y, z);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform3ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3ui64NV, s->GlesSpy::imports().glUniform3ui64NV);
        s->GlesSpy::imports().glUniform3ui64NV(location, x, y, z);
        GAPID_DEBUG("glUniform3ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3ui64NV");
    s->glUniform3ui64NV(&observer, location, x, y, z);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform3ui64NV() -- done");
}
EXPORT void STDCALL glUniform3ui64vNV(GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform3ui64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform3ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform3ui64vNV, s->GlesSpy::imports().glUniform3ui64vNV);
        s->GlesSpy::imports().glUniform3ui64vNV(location, count, value);
        GAPID_DEBUG("glUniform3ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3ui64vNV");
    s->glUniform3ui64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform3ui64vNV() -- done");
}
EXPORT void STDCALL glUniform4i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4i64NV(%" PRId32 ", %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z, w);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform4i64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4i64NV, s->GlesSpy::imports().glUniform4i64NV);
        s->GlesSpy::imports().glUniform4i64NV(location, x, y, z, w);
        GAPID_DEBUG("glUniform4i64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4i64NV");
    s->glUniform4i64NV(&observer, location, x, y, z, w);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform4i64NV() -- done");
}
EXPORT void STDCALL glUniform4i64vNV(GLint location, GLsizei count, GLint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4i64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform4i64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4i64vNV, s->GlesSpy::imports().glUniform4i64vNV);
        s->GlesSpy::imports().glUniform4i64vNV(location, count, value);
        GAPID_DEBUG("glUniform4i64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4i64vNV");
    s->glUniform4i64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform4i64vNV() -- done");
}
EXPORT void STDCALL glUniform4ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4ui64NV(%" PRId32 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", location, x, y, z, w);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform4ui64NV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4ui64NV, s->GlesSpy::imports().glUniform4ui64NV);
        s->GlesSpy::imports().glUniform4ui64NV(location, x, y, z, w);
        GAPID_DEBUG("glUniform4ui64NV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4ui64NV");
    s->glUniform4ui64NV(&observer, location, x, y, z, w);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform4ui64NV() -- done");
}
EXPORT void STDCALL glUniform4ui64vNV(GLint location, GLsizei count, GLuint64EXT* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniform4ui64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniform4ui64vNV at %p: GAPII re-entered. Just invoking imported function at %p", glUniform4ui64vNV, s->GlesSpy::imports().glUniform4ui64vNV);
        s->GlesSpy::imports().glUniform4ui64vNV(location, count, value);
        GAPID_DEBUG("glUniform4ui64vNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4ui64vNV");
    s->glUniform4ui64vNV(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniform4ui64vNV() -- done");
}
EXPORT void STDCALL glUniformHandleui64IMG(GLint location, GLuint64 value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformHandleui64IMG(%" PRId32 ", %" PRIu64 ")", location, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniformHandleui64IMG at %p: GAPII re-entered. Just invoking imported function at %p", glUniformHandleui64IMG, s->GlesSpy::imports().glUniformHandleui64IMG);
        s->GlesSpy::imports().glUniformHandleui64IMG(location, value);
        GAPID_DEBUG("glUniformHandleui64IMG() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformHandleui64IMG");
    s->glUniformHandleui64IMG(&observer, location, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniformHandleui64IMG() -- done");
}
EXPORT void STDCALL glUniformHandleui64vIMG(GLint location, GLsizei count, GLuint64* value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUniformHandleui64vIMG(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
    if (!s->try_to_enter()) {
        GAPID_INFO("glUniformHandleui64vIMG at %p: GAPII re-entered. Just invoking imported function at %p", glUniformHandleui64vIMG, s->GlesSpy::imports().glUniformHandleui64vIMG);
        s->GlesSpy::imports().glUniformHandleui64vIMG(location, count, value);
        GAPID_DEBUG("glUniformHandleui64vIMG() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformHandleui64vIMG");
    s->glUniformHandleui64vIMG(&observer, location, count, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniformHandleui64vIMG() -- done");
}
EXPORT void STDCALL glViewportArrayvOES(GLuint first, GLsizei count, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportArrayvOES(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
    if (!s->try_to_enter()) {
        GAPID_INFO("glViewportArrayvOES at %p: GAPII re-entered. Just invoking imported function at %p", glViewportArrayvOES, s->GlesSpy::imports().glViewportArrayvOES);
        s->GlesSpy::imports().glViewportArrayvOES(first, count, v);
        GAPID_DEBUG("glViewportArrayvOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportArrayvOES");
    s->glViewportArrayvOES(&observer, first, count, v);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glViewportArrayvOES() -- done");
}
EXPORT void STDCALL glViewportIndexedfOES(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportIndexedfOES(%" PRIu32 ", %f, %f, %f, %f)", index, x, y, w, h);
    if (!s->try_to_enter()) {
        GAPID_INFO("glViewportIndexedfOES at %p: GAPII re-entered. Just invoking imported function at %p", glViewportIndexedfOES, s->GlesSpy::imports().glViewportIndexedfOES);
        s->GlesSpy::imports().glViewportIndexedfOES(index, x, y, w, h);
        GAPID_DEBUG("glViewportIndexedfOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportIndexedfOES");
    s->glViewportIndexedfOES(&observer, index, x, y, w, h);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glViewportIndexedfOES() -- done");
}
EXPORT void STDCALL glViewportIndexedfvOES(GLuint index, GLfloat* v) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportIndexedfvOES(%" PRIu32 ", %p)", index, v);
    if (!s->try_to_enter()) {
        GAPID_INFO("glViewportIndexedfvOES at %p: GAPII re-entered. Just invoking imported function at %p", glViewportIndexedfvOES, s->GlesSpy::imports().glViewportIndexedfvOES);
        s->GlesSpy::imports().glViewportIndexedfvOES(index, v);
        GAPID_DEBUG("glViewportIndexedfvOES() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportIndexedfvOES");
    s->glViewportIndexedfvOES(&observer, index, v);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glViewportIndexedfvOES() -- done");
}
EXPORT void STDCALL glViewportSwizzleNV(GLuint index, uint32_t swizzlex, uint32_t swizzley, uint32_t swizzlez, uint32_t swizzlew) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glViewportSwizzleNV(%" PRIu32 ", %u, %u, %u, %u)", index, swizzlex, swizzley, swizzlez, swizzlew);
    if (!s->try_to_enter()) {
        GAPID_INFO("glViewportSwizzleNV at %p: GAPII re-entered. Just invoking imported function at %p", glViewportSwizzleNV, s->GlesSpy::imports().glViewportSwizzleNV);
        s->GlesSpy::imports().glViewportSwizzleNV(index, swizzlex, swizzley, swizzlez, swizzlew);
        GAPID_DEBUG("glViewportSwizzleNV() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewportSwizzleNV");
    s->glViewportSwizzleNV(&observer, index, swizzlex, swizzley, swizzlez, swizzlew);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glViewportSwizzleNV() -- done");
}
EXPORT void STDCALL glWindowRectanglesEXT(uint32_t mode, GLsizei count, GLint* box) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glWindowRectanglesEXT(%u, %" PRId32 ", %p)", mode, count, box);
    if (!s->try_to_enter()) {
        GAPID_INFO("glWindowRectanglesEXT at %p: GAPII re-entered. Just invoking imported function at %p", glWindowRectanglesEXT, s->GlesSpy::imports().glWindowRectanglesEXT);
        s->GlesSpy::imports().glWindowRectanglesEXT(mode, count, box);
        GAPID_DEBUG("glWindowRectanglesEXT() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glWindowRectanglesEXT");
    s->glWindowRectanglesEXT(&observer, mode, count, box);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glWindowRectanglesEXT() -- done");
}
EXPORT void STDCALL glBlendBarrier() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendBarrier()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendBarrier");
    s->glBlendBarrier(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendColor");
    s->glBlendColor(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBlendColor() -- done");
}
EXPORT void STDCALL glBlendEquation(uint32_t equation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquation(%u)", equation);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquation");
    s->glBlendEquation(&observer, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationSeparate");
    s->glBlendEquationSeparate(&observer, rgb, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationSeparatei");
    s->glBlendEquationSeparatei(&observer, buf, modeRGB, modeAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationi");
    s->glBlendEquationi(&observer, buf, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFunc");
    s->glBlendFunc(&observer, src_factor, dst_factor);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFuncSeparate");
    s->glBlendFuncSeparate(&observer, src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFuncSeparatei");
    s->glBlendFuncSeparatei(&observer, buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFunci");
    s->glBlendFunci(&observer, buf, src, dst);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBlendFunci() -- done");
}
EXPORT void STDCALL glDepthFunc(uint32_t function) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthFunc(%u)", function);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthFunc");
    s->glDepthFunc(&observer, function);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSampleCoverage");
    s->glSampleCoverage(&observer, value, invert);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSampleMaski");
    s->glSampleMaski(&observer, maskNumber, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScissor");
    s->glScissor(&observer, x, y, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilFunc");
    s->glStencilFunc(&observer, func, ref, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilFuncSeparate");
    s->glStencilFuncSeparate(&observer, face, function, reference_value, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilOp");
    s->glStencilOp(&observer, fail, zfail, zpass);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilOpSeparate");
    s->glStencilOpSeparate(&observer, face, stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindFramebuffer");
    s->glBindFramebuffer(&observer, target, framebuffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindRenderbuffer");
    s->glBindRenderbuffer(&observer, target, renderbuffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlitFramebuffer");
    s->glBlitFramebuffer(&observer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBlitFramebuffer() -- done");
}
EXPORT uint32_t STDCALL glCheckFramebufferStatus(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCheckFramebufferStatus(%u)", target);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCheckFramebufferStatus");
    auto _result_ = s->glCheckFramebufferStatus(&observer, target);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCheckFramebufferStatus() -- done");
    return _result_;
}
EXPORT void STDCALL glClear(uint32_t mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClear(%u)", mask);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClear");
    s->glClear(&observer, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearBufferfi");
    s->glClearBufferfi(&observer, buffer, drawbuffer, depth, stencil);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearBufferfv");
    s->glClearBufferfv(&observer, buffer, drawbuffer, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearBufferiv");
    s->glClearBufferiv(&observer, buffer, drawbuffer, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearBufferuiv");
    s->glClearBufferuiv(&observer, buffer, drawbuffer, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearColor");
    s->glClearColor(&observer, r, g, b, a);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearColor() -- done");
}
EXPORT void STDCALL glClearDepthf(GLfloat depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthf(%f)", depth);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearDepthf");
    s->glClearDepthf(&observer, depth);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearDepthf() -- done");
}
EXPORT void STDCALL glClearStencil(GLint stencil) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearStencil(%" PRId32 ")", stencil);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearStencil");
    s->glClearStencil(&observer, stencil);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColorMask");
    s->glColorMask(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColorMaski");
    s->glColorMaski(&observer, index, r, g, b, a);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteFramebuffers");
    s->glDeleteFramebuffers(&observer, count, framebuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteRenderbuffers");
    s->glDeleteRenderbuffers(&observer, count, renderbuffers);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeleteRenderbuffers() -- done");
}
EXPORT void STDCALL glDepthMask(GLboolean enabled) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDepthMask(%" PRIu8 ")", enabled);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthMask");
    s->glDepthMask(&observer, enabled);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawBuffers");
    s->glDrawBuffers(&observer, n, bufs);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferParameteri");
    s->glFramebufferParameteri(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferRenderbuffer");
    s->glFramebufferRenderbuffer(&observer, framebuffer_target, framebuffer_attachment, renderbuffer_target, renderbuffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture");
    s->glFramebufferTexture(&observer, target, attachment, texture, level);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture2D");
    s->glFramebufferTexture2D(&observer, framebuffer_target, framebuffer_attachment, texture_target, texture, level);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTextureLayer");
    s->glFramebufferTextureLayer(&observer, target, attachment, texture, level, layer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenFramebuffers");
    s->glGenFramebuffers(&observer, count, framebuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenRenderbuffers");
    s->glGenRenderbuffers(&observer, count, renderbuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFramebufferAttachmentParameteriv");
    s->glGetFramebufferAttachmentParameteriv(&observer, framebuffer_target, attachment, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFramebufferParameteriv");
    s->glGetFramebufferParameteriv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetRenderbufferParameteriv");
    s->glGetRenderbufferParameteriv(&observer, target, parameter, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glInvalidateFramebuffer");
    s->glInvalidateFramebuffer(&observer, target, count, attachments);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glInvalidateSubFramebuffer");
    s->glInvalidateSubFramebuffer(&observer, target, numAttachments, attachments, x, y, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glInvalidateSubFramebuffer() -- done");
}
EXPORT GLboolean STDCALL glIsFramebuffer(FramebufferId framebuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsFramebuffer(%" PRIu32 ")", framebuffer);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsFramebuffer");
    auto _result_ = s->glIsFramebuffer(&observer, framebuffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsFramebuffer() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsRenderbuffer(RenderbufferId renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsRenderbuffer(%" PRIu32 ")", renderbuffer);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsRenderbuffer");
    auto _result_ = s->glIsRenderbuffer(&observer, renderbuffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsRenderbuffer() -- done");
    return _result_;
}
EXPORT void STDCALL glReadBuffer(uint32_t src) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReadBuffer(%u)", src);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadBuffer");
    s->glReadBuffer(&observer, src);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadPixels");
    s->glReadPixels(&observer, x, y, width, height, format, type, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReadnPixels");
    s->glReadnPixels(&observer, x, y, width, height, format, type, bufSize, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorage");
    s->glRenderbufferStorage(&observer, target, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageMultisample");
    s->glRenderbufferStorageMultisample(&observer, target, samples, internalformat, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glRenderbufferStorageMultisample() -- done");
}
EXPORT void STDCALL glStencilMask(GLuint mask) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glStencilMask(%" PRIu32 ")", mask);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilMask");
    s->glStencilMask(&observer, mask);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glStencilMaskSeparate");
    s->glStencilMaskSeparate(&observer, face, mask);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glStencilMaskSeparate() -- done");
}
EXPORT void STDCALL glDisable(uint32_t capability) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisable(%u)", capability);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisable");
    s->glDisable(&observer, capability);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisablei");
    s->glDisablei(&observer, capability, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDisablei() -- done");
}
EXPORT void STDCALL glEnable(uint32_t capability) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnable(%u)", capability);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnable");
    s->glEnable(&observer, capability);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnablei");
    s->glEnablei(&observer, capability, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glEnablei() -- done");
}
EXPORT void STDCALL glFinish() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFinish()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFinish");
    s->glFinish(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFinish() -- done");
}
EXPORT void STDCALL glFlush() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFlush()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFlush");
    s->glFlush(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glFlush() -- done");
}
EXPORT uint32_t STDCALL glGetError() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetError()");
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetError");
    auto _result_ = s->glGetError(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetError() -- done");
    return _result_;
}
EXPORT uint32_t STDCALL glGetGraphicsResetStatus() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetGraphicsResetStatus()");
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetGraphicsResetStatus");
    auto _result_ = s->glGetGraphicsResetStatus(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glHint");
    s->glHint(&observer, target, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glActiveShaderProgram");
    s->glActiveShaderProgram(&observer, pipeline, program);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glAttachShader");
    s->glAttachShader(&observer, program, shader);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindAttribLocation");
    s->glBindAttribLocation(&observer, program, location, name);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindAttribLocation() -- done");
}
EXPORT void STDCALL glBindProgramPipeline(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindProgramPipeline(%" PRIu32 ")", pipeline);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindProgramPipeline");
    s->glBindProgramPipeline(&observer, pipeline);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindProgramPipeline() -- done");
}
EXPORT void STDCALL glCompileShader(ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCompileShader(%" PRIu32 ")", shader);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompileShader");
    s->glCompileShader(&observer, shader);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCompileShader() -- done");
}
EXPORT ProgramId STDCALL glCreateProgram() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreateProgram()");
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCreateProgram");
    auto _result_ = s->glCreateProgram(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCreateProgram() -- done");
    return _result_;
}
EXPORT ShaderId STDCALL glCreateShader(uint32_t type) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCreateShader(%u)", type);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCreateShader");
    auto _result_ = s->glCreateShader(&observer, type);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCreateShaderProgramv");
    auto _result_ = s->glCreateShaderProgramv(&observer, type, count, strings);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCreateShaderProgramv() -- done");
    return _result_;
}
EXPORT void STDCALL glDeleteProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteProgram(%" PRIu32 ")", program);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteProgram");
    s->glDeleteProgram(&observer, program);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteProgramPipelines");
    s->glDeleteProgramPipelines(&observer, n, pipelines);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeleteProgramPipelines() -- done");
}
EXPORT void STDCALL glDeleteShader(ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteShader(%" PRIu32 ")", shader);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteShader");
    s->glDeleteShader(&observer, shader);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDetachShader");
    s->glDetachShader(&observer, program, shader);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDispatchCompute");
    s->glDispatchCompute(&observer, num_groups_x, num_groups_y, num_groups_z);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDispatchCompute() -- done");
}
EXPORT void STDCALL glDispatchComputeIndirect(GLintptr indirect) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDispatchComputeIndirect(%" PRId32 ")", indirect);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDispatchComputeIndirect");
    s->glDispatchComputeIndirect(&observer, indirect);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenProgramPipelines");
    s->glGenProgramPipelines(&observer, n, pipelines);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetActiveAttrib");
    s->glGetActiveAttrib(&observer, program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetActiveUniform");
    s->glGetActiveUniform(&observer, program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetActiveUniformBlockName");
    s->glGetActiveUniformBlockName(&observer, program, uniform_block_index, buffer_size, buffer_bytes_written, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetActiveUniformBlockiv");
    s->glGetActiveUniformBlockiv(&observer, program, uniform_block_index, parameter_name, parameters);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetActiveUniformsiv");
    s->glGetActiveUniformsiv(&observer, program, uniform_count, uniform_indices, parameter_name, parameters);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetAttachedShaders");
    s->glGetAttachedShaders(&observer, program, buffer_length, shaders_length_written, shaders);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetAttribLocation");
    auto _result_ = s->glGetAttribLocation(&observer, program, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFragDataLocation");
    auto _result_ = s->glGetFragDataLocation(&observer, program, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramBinary");
    s->glGetProgramBinary(&observer, program, bufSize, length, binaryFormat, binary);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramInfoLog");
    s->glGetProgramInfoLog(&observer, program, buffer_length, string_length_written, info);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramInterfaceiv");
    s->glGetProgramInterfaceiv(&observer, program, programInterface, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramPipelineInfoLog");
    s->glGetProgramPipelineInfoLog(&observer, pipeline, bufSize, length, infoLog);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramPipelineiv");
    s->glGetProgramPipelineiv(&observer, pipeline, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramResourceIndex");
    auto _result_ = s->glGetProgramResourceIndex(&observer, program, programInterface, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramResourceLocation");
    auto _result_ = s->glGetProgramResourceLocation(&observer, program, programInterface, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramResourceName");
    s->glGetProgramResourceName(&observer, program, programInterface, index, bufSize, length, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramResourceiv");
    s->glGetProgramResourceiv(&observer, program, programInterface, index, propCount, props, bufSize, length, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetProgramiv");
    s->glGetProgramiv(&observer, program, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetShaderInfoLog");
    s->glGetShaderInfoLog(&observer, shader, buffer_length, string_length_written, info);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetShaderPrecisionFormat");
    s->glGetShaderPrecisionFormat(&observer, shader_type, precision_type, range, precision);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetShaderSource");
    s->glGetShaderSource(&observer, shader, buffer_length, string_length_written, source);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetShaderiv");
    s->glGetShaderiv(&observer, shader, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformBlockIndex");
    auto _result_ = s->glGetUniformBlockIndex(&observer, program, uniformBlockName);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformIndices");
    s->glGetUniformIndices(&observer, program, uniformCount, uniformNames, uniformIndices);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformLocation");
    auto _result_ = s->glGetUniformLocation(&observer, program, name);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformfv");
    s->glGetUniformfv(&observer, program, location, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformiv");
    s->glGetUniformiv(&observer, program, location, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetUniformuiv");
    s->glGetUniformuiv(&observer, program, location, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformfv");
    s->glGetnUniformfv(&observer, program, location, bufSize, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformiv");
    s->glGetnUniformiv(&observer, program, location, bufSize, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetnUniformuiv");
    s->glGetnUniformuiv(&observer, program, location, bufSize, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetnUniformuiv() -- done");
}
EXPORT GLboolean STDCALL glIsProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsProgram(%" PRIu32 ")", program);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsProgram");
    auto _result_ = s->glIsProgram(&observer, program);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsProgram() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsProgramPipeline(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsProgramPipeline(%" PRIu32 ")", pipeline);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsProgramPipeline");
    auto _result_ = s->glIsProgramPipeline(&observer, pipeline);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsProgramPipeline() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsShader(ShaderId shader) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsShader(%" PRIu32 ")", shader);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsShader");
    auto _result_ = s->glIsShader(&observer, shader);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsShader() -- done");
    return _result_;
}
EXPORT void STDCALL glLinkProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLinkProgram(%" PRIu32 ")", program);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLinkProgram");
    s->glLinkProgram(&observer, program);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLinkProgram() -- done");
}
EXPORT void STDCALL glMemoryBarrier(uint32_t barriers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMemoryBarrier(%u)", barriers);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMemoryBarrier");
    s->glMemoryBarrier(&observer, barriers);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMemoryBarrier() -- done");
}
EXPORT void STDCALL glMemoryBarrierByRegion(uint32_t barriers) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMemoryBarrierByRegion(%u)", barriers);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMemoryBarrierByRegion");
    s->glMemoryBarrierByRegion(&observer, barriers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramBinary");
    s->glProgramBinary(&observer, program, binaryFormat, binary, length);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramParameteri");
    s->glProgramParameteri(&observer, program, pname, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1f");
    s->glProgramUniform1f(&observer, program, location, value0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1fv");
    s->glProgramUniform1fv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1i");
    s->glProgramUniform1i(&observer, program, location, value0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1iv");
    s->glProgramUniform1iv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1ui");
    s->glProgramUniform1ui(&observer, program, location, value0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform1uiv");
    s->glProgramUniform1uiv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2f");
    s->glProgramUniform2f(&observer, program, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2fv");
    s->glProgramUniform2fv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2i");
    s->glProgramUniform2i(&observer, program, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2iv");
    s->glProgramUniform2iv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2ui");
    s->glProgramUniform2ui(&observer, program, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform2uiv");
    s->glProgramUniform2uiv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3f");
    s->glProgramUniform3f(&observer, program, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3fv");
    s->glProgramUniform3fv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3i");
    s->glProgramUniform3i(&observer, program, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3iv");
    s->glProgramUniform3iv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3ui");
    s->glProgramUniform3ui(&observer, program, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform3uiv");
    s->glProgramUniform3uiv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4f");
    s->glProgramUniform4f(&observer, program, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4fv");
    s->glProgramUniform4fv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4i");
    s->glProgramUniform4i(&observer, program, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4iv");
    s->glProgramUniform4iv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4ui");
    s->glProgramUniform4ui(&observer, program, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniform4uiv");
    s->glProgramUniform4uiv(&observer, program, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix2fv");
    s->glProgramUniformMatrix2fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix2x3fv");
    s->glProgramUniformMatrix2x3fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix2x4fv");
    s->glProgramUniformMatrix2x4fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix3fv");
    s->glProgramUniformMatrix3fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix3x2fv");
    s->glProgramUniformMatrix3x2fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix3x4fv");
    s->glProgramUniformMatrix3x4fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix4fv");
    s->glProgramUniformMatrix4fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix4x2fv");
    s->glProgramUniformMatrix4x2fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glProgramUniformMatrix4x3fv");
    s->glProgramUniformMatrix4x3fv(&observer, program, location, count, transpose, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glProgramUniformMatrix4x3fv() -- done");
}
EXPORT void STDCALL glReleaseShaderCompiler() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glReleaseShaderCompiler()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glReleaseShaderCompiler");
    s->glReleaseShaderCompiler(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glShaderBinary");
    s->glShaderBinary(&observer, count, shaders, binary_format, binary, binary_size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glShaderSource");
    s->glShaderSource(&observer, shader, count, source, length);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1f");
    s->glUniform1f(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1fv");
    s->glUniform1fv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1i");
    s->glUniform1i(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1iv");
    s->glUniform1iv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1ui");
    s->glUniform1ui(&observer, location, value0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform1uiv");
    s->glUniform1uiv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2f");
    s->glUniform2f(&observer, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2fv");
    s->glUniform2fv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2i");
    s->glUniform2i(&observer, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2iv");
    s->glUniform2iv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2ui");
    s->glUniform2ui(&observer, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform2uiv");
    s->glUniform2uiv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3f");
    s->glUniform3f(&observer, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3fv");
    s->glUniform3fv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3i");
    s->glUniform3i(&observer, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3iv");
    s->glUniform3iv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3ui");
    s->glUniform3ui(&observer, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform3uiv");
    s->glUniform3uiv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4f");
    s->glUniform4f(&observer, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4fv");
    s->glUniform4fv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4i");
    s->glUniform4i(&observer, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4iv");
    s->glUniform4iv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4ui");
    s->glUniform4ui(&observer, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniform4uiv");
    s->glUniform4uiv(&observer, location, count, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformBlockBinding");
    s->glUniformBlockBinding(&observer, program, uniform_block_index, uniform_block_binding);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix2fv");
    s->glUniformMatrix2fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix2x3fv");
    s->glUniformMatrix2x3fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix2x4fv");
    s->glUniformMatrix2x4fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix3fv");
    s->glUniformMatrix3fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix3x2fv");
    s->glUniformMatrix3x2fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix3x4fv");
    s->glUniformMatrix3x4fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix4fv");
    s->glUniformMatrix4fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix4x2fv");
    s->glUniformMatrix4x2fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUniformMatrix4x3fv");
    s->glUniformMatrix4x3fv(&observer, location, count, transpose, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUniformMatrix4x3fv() -- done");
}
EXPORT void STDCALL glUseProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glUseProgram(%" PRIu32 ")", program);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUseProgram");
    s->glUseProgram(&observer, program);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glUseProgramStages");
    s->glUseProgramStages(&observer, pipeline, stages, program);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glUseProgramStages() -- done");
}
EXPORT void STDCALL glValidateProgram(ProgramId program) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glValidateProgram(%" PRIu32 ")", program);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glValidateProgram");
    s->glValidateProgram(&observer, program);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glValidateProgram() -- done");
}
EXPORT void STDCALL glValidateProgramPipeline(PipelineId pipeline) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glValidateProgramPipeline(%" PRIu32 ")", pipeline);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glValidateProgramPipeline");
    s->glValidateProgramPipeline(&observer, pipeline);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glValidateProgramPipeline() -- done");
}
EXPORT void STDCALL glCullFace(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCullFace(%u)", mode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCullFace");
    s->glCullFace(&observer, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangef");
    s->glDepthRangef(&observer, near, far);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDepthRangef() -- done");
}
EXPORT void STDCALL glFrontFace(uint32_t orientation) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glFrontFace(%u)", orientation);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFrontFace");
    s->glFrontFace(&observer, orientation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetMultisamplefv");
    s->glGetMultisamplefv(&observer, pname, index, val);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetMultisamplefv() -- done");
}
EXPORT void STDCALL glLineWidth(GLfloat width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLineWidth(%f)", width);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLineWidth");
    s->glLineWidth(&observer, width);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLineWidth() -- done");
}
EXPORT void STDCALL glMinSampleShading(GLfloat value) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMinSampleShading(%f)", value);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMinSampleShading");
    s->glMinSampleShading(&observer, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPolygonOffset");
    s->glPolygonOffset(&observer, scale_factor, units);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glViewport");
    s->glViewport(&observer, x, y, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetBooleani_v");
    s->glGetBooleani_v(&observer, param, index, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetBooleanv");
    s->glGetBooleanv(&observer, param, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFloatv");
    s->glGetFloatv(&observer, param, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetInteger64i_v");
    s->glGetInteger64i_v(&observer, param, index, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetInteger64v");
    s->glGetInteger64v(&observer, param, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetIntegeri_v");
    s->glGetIntegeri_v(&observer, param, index, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetIntegerv");
    s->glGetIntegerv(&observer, param, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetInternalformativ");
    s->glGetInternalformativ(&observer, target, internalformat, pname, bufSize, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetInternalformativ() -- done");
}
EXPORT GLubyte* STDCALL glGetString(uint32_t param) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGetString(%u)", param);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetString");
    auto _result_ = s->glGetString(&observer, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetStringi");
    auto _result_ = s->glGetStringi(&observer, name, index);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetStringi() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsEnabled(uint32_t capability) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsEnabled(%u)", capability);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsEnabled");
    auto _result_ = s->glIsEnabled(&observer, capability);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsEnabledi");
    auto _result_ = s->glIsEnabledi(&observer, capability, index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClientWaitSync");
    auto _result_ = s->glClientWaitSync(&observer, sync, syncFlags, timeout);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClientWaitSync() -- done");
    return _result_;
}
EXPORT void STDCALL glDeleteSync(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDeleteSync(%p)", sync);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteSync");
    s->glDeleteSync(&observer, sync);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFenceSync");
    auto _result_ = s->glFenceSync(&observer, condition, syncFlags);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSynciv");
    s->glGetSynciv(&observer, sync, pname, bufSize, length, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetSynciv() -- done");
}
EXPORT GLboolean STDCALL glIsSync(GLsync sync) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsSync(%p)", sync);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsSync");
    auto _result_ = s->glIsSync(&observer, sync);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glWaitSync");
    s->glWaitSync(&observer, sync, syncFlags, timeout);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glWaitSync() -- done");
}
EXPORT void STDCALL glActiveTexture(uint32_t unit) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glActiveTexture(%u)", unit);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glActiveTexture");
    s->glActiveTexture(&observer, unit);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindImageTexture");
    s->glBindImageTexture(&observer, unit, texture, level, layered, layer, access, format);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindSampler");
    s->glBindSampler(&observer, index, sampler);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindTexture");
    s->glBindTexture(&observer, target, texture);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompressedTexImage2D");
    s->glCompressedTexImage2D(&observer, target, level, format, width, height, border, image_size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompressedTexImage3D");
    s->glCompressedTexImage3D(&observer, target, level, internalformat, width, height, depth, border, image_size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompressedTexSubImage2D");
    s->glCompressedTexSubImage2D(&observer, target, level, xoffset, yoffset, width, height, format, image_size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCompressedTexSubImage3D");
    s->glCompressedTexSubImage3D(&observer, target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyImageSubData");
    s->glCopyImageSubData(&observer, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glCopyImageSubData() -- done");
}
EXPORT void STDCALL glCopyTexImage2D(uint32_t target, GLint level, uint32_t internalformat, 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, internalformat, x, y, width, height, border);
    if (!s->try_to_enter()) {
        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, internalformat, x, y, width, height, border);
        GAPID_DEBUG("glCopyTexImage2D() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyTexImage2D");
    s->glCopyTexImage2D(&observer, target, level, internalformat, x, y, width, height, border);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyTexSubImage2D");
    s->glCopyTexSubImage2D(&observer, target, level, xoffset, yoffset, x, y, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCopyTexSubImage3D");
    s->glCopyTexSubImage3D(&observer, target, level, xoffset, yoffset, zoffset, x, y, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteSamplers");
    s->glDeleteSamplers(&observer, count, samplers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteTextures");
    s->glDeleteTextures(&observer, count, textures);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenSamplers");
    s->glGenSamplers(&observer, count, samplers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenTextures");
    s->glGenTextures(&observer, count, textures);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGenTextures() -- done");
}
EXPORT void STDCALL glGenerateMipmap(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenerateMipmap(%u)", target);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenerateMipmap");
    s->glGenerateMipmap(&observer, target);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterIiv");
    s->glGetSamplerParameterIiv(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterIuiv");
    s->glGetSamplerParameterIuiv(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameterfv");
    s->glGetSamplerParameterfv(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetSamplerParameteriv");
    s->glGetSamplerParameteriv(&observer, sampler, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexLevelParameterfv");
    s->glGetTexLevelParameterfv(&observer, target, level, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexLevelParameteriv");
    s->glGetTexLevelParameteriv(&observer, target, level, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterIiv");
    s->glGetTexParameterIiv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterIuiv");
    s->glGetTexParameterIuiv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterfv");
    s->glGetTexParameterfv(&observer, target, parameter, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameteriv");
    s->glGetTexParameteriv(&observer, target, parameter, values);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetTexParameteriv() -- done");
}
EXPORT GLboolean STDCALL glIsSampler(SamplerId sampler) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsSampler(%" PRIu32 ")", sampler);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsSampler");
    auto _result_ = s->glIsSampler(&observer, sampler);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsSampler() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsTexture(TextureId texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsTexture(%" PRIu32 ")", texture);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsTexture");
    auto _result_ = s->glIsTexture(&observer, texture);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPixelStorei");
    s->glPixelStorei(&observer, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterIiv");
    s->glSamplerParameterIiv(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterIuiv");
    s->glSamplerParameterIuiv(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterf");
    s->glSamplerParameterf(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameterfv");
    s->glSamplerParameterfv(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameteri");
    s->glSamplerParameteri(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSamplerParameteriv");
    s->glSamplerParameteriv(&observer, sampler, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexBuffer");
    s->glTexBuffer(&observer, target, internalformat, buffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexBufferRange");
    s->glTexBufferRange(&observer, target, internalformat, buffer, offset, size);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexBufferRange() -- done");
}
EXPORT void STDCALL glTexImage2D(uint32_t target, GLint level, GLint internalformat, 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, internalformat, width, height, border, format, type, data);
    if (!s->try_to_enter()) {
        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, internalformat, width, height, border, format, type, data);
        GAPID_DEBUG("glTexImage2D() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexImage2D");
    s->glTexImage2D(&observer, target, level, internalformat, width, height, border, format, type, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexImage3D");
    s->glTexImage3D(&observer, target, level, internalformat, width, height, depth, border, format, type, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterIiv");
    s->glTexParameterIiv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterIuiv");
    s->glTexParameterIuiv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterf");
    s->glTexParameterf(&observer, target, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterfv");
    s->glTexParameterfv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameteri");
    s->glTexParameteri(&observer, target, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameteriv");
    s->glTexParameteriv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage2D");
    s->glTexStorage2D(&observer, target, levels, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage2DMultisample");
    s->glTexStorage2DMultisample(&observer, target, samples, internalformat, width, height, fixedsamplelocations);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage3D");
    s->glTexStorage3D(&observer, target, levels, internalformat, width, height, depth);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage3DMultisample");
    s->glTexStorage3DMultisample(&observer, target, samples, internalformat, width, height, depth, fixedsamplelocations);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexSubImage2D");
    s->glTexSubImage2D(&observer, target, level, xoffset, yoffset, width, height, format, type, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexSubImage3D");
    s->glTexSubImage3D(&observer, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexSubImage3D() -- done");
}
EXPORT void STDCALL glBeginTransformFeedback(uint32_t primitiveMode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBeginTransformFeedback(%u)", primitiveMode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBeginTransformFeedback");
    s->glBeginTransformFeedback(&observer, primitiveMode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindTransformFeedback");
    s->glBindTransformFeedback(&observer, target, id);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteTransformFeedbacks");
    s->glDeleteTransformFeedbacks(&observer, n, ids);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeleteTransformFeedbacks() -- done");
}
EXPORT void STDCALL glEndTransformFeedback() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEndTransformFeedback()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEndTransformFeedback");
    s->glEndTransformFeedback(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenTransformFeedbacks");
    s->glGenTransformFeedbacks(&observer, n, ids);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTransformFeedbackVarying");
    s->glGetTransformFeedbackVarying(&observer, program, index, bufSize, length, size, type, name);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetTransformFeedbackVarying() -- done");
}
EXPORT GLboolean STDCALL glIsTransformFeedback(TransformFeedbackId id) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsTransformFeedback(%" PRIu32 ")", id);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsTransformFeedback");
    auto _result_ = s->glIsTransformFeedback(&observer, id);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsTransformFeedback() -- done");
    return _result_;
}
EXPORT void STDCALL glPauseTransformFeedback() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPauseTransformFeedback()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPauseTransformFeedback");
    s->glPauseTransformFeedback(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPauseTransformFeedback() -- done");
}
EXPORT void STDCALL glResumeTransformFeedback() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glResumeTransformFeedback()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glResumeTransformFeedback");
    s->glResumeTransformFeedback(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTransformFeedbackVaryings");
    s->glTransformFeedbackVaryings(&observer, program, count, varyings, bufferMode);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTransformFeedbackVaryings() -- done");
}
EXPORT void STDCALL glBindVertexArray(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindVertexArray(%" PRIu32 ")", array);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindVertexArray");
    s->glBindVertexArray(&observer, array);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindVertexBuffer");
    s->glBindVertexBuffer(&observer, binding_index, buffer, offset, stride);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteVertexArrays");
    s->glDeleteVertexArrays(&observer, count, arrays);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDeleteVertexArrays() -- done");
}
EXPORT void STDCALL glDisableVertexAttribArray(AttributeLocation location) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableVertexAttribArray(%" PRIu32 ")", location);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisableVertexAttribArray");
    s->glDisableVertexAttribArray(&observer, location);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDisableVertexAttribArray() -- done");
}
EXPORT void STDCALL glEnableVertexAttribArray(AttributeLocation location) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableVertexAttribArray(%" PRIu32 ")", location);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnableVertexAttribArray");
    s->glEnableVertexAttribArray(&observer, location);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenVertexArrays");
    s->glGenVertexArrays(&observer, count, arrays);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetVertexAttribIiv");
    s->glGetVertexAttribIiv(&observer, index, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetVertexAttribIuiv");
    s->glGetVertexAttribIuiv(&observer, index, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetVertexAttribPointerv");
    s->glGetVertexAttribPointerv(&observer, index, pname, pointer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetVertexAttribfv");
    s->glGetVertexAttribfv(&observer, index, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetVertexAttribiv");
    s->glGetVertexAttribiv(&observer, index, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetVertexAttribiv() -- done");
}
EXPORT GLboolean STDCALL glIsVertexArray(VertexArrayId array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsVertexArray(%" PRIu32 ")", array);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsVertexArray");
    auto _result_ = s->glIsVertexArray(&observer, array);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib1f");
    s->glVertexAttrib1f(&observer, location, value0);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib1fv");
    s->glVertexAttrib1fv(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib2f");
    s->glVertexAttrib2f(&observer, location, value0, value1);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib2fv");
    s->glVertexAttrib2fv(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib3f");
    s->glVertexAttrib3f(&observer, location, value0, value1, value2);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib3fv");
    s->glVertexAttrib3fv(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib4f");
    s->glVertexAttrib4f(&observer, location, value0, value1, value2, value3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttrib4fv");
    s->glVertexAttrib4fv(&observer, location, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribBinding");
    s->glVertexAttribBinding(&observer, index, binding_index);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribDivisor");
    s->glVertexAttribDivisor(&observer, index, divisor);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribFormat");
    s->glVertexAttribFormat(&observer, index, size, type, normalized, relativeoffset);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribI4i");
    s->glVertexAttribI4i(&observer, index, x, y, z, w);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribI4iv");
    s->glVertexAttribI4iv(&observer, index, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribI4ui");
    s->glVertexAttribI4ui(&observer, index, x, y, z, w);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribI4uiv");
    s->glVertexAttribI4uiv(&observer, index, values);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribIFormat");
    s->glVertexAttribIFormat(&observer, index, size, type, relativeoffset);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribIPointer");
    s->glVertexAttribIPointer(&observer, location, size, type, stride, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexAttribPointer");
    s->glVertexAttribPointer(&observer, location, size, type, normalized, stride, data);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexBindingDivisor");
    s->glVertexBindingDivisor(&observer, binding_index, divisor);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glVertexBindingDivisor() -- done");
}
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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glXCreateContext");
    auto _result_ = s->glXCreateContext(&observer, dpy, vis, shareList, direct);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glXCreateNewContext");
    auto _result_ = s->glXCreateNewContext(&observer, display, fbconfig, type, shared, direct);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glXMakeContextCurrent");
    auto _result_ = s->glXMakeContextCurrent(&observer, display, draw, read, ctx);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glXMakeCurrent");
    auto _result_ = s->glXMakeCurrent(&observer, display, drawable, ctx);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glXSwapBuffers");
    s->glXSwapBuffers(&observer, display, drawable);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glXQueryDrawable");
    auto _result_ = s->glXQueryDrawable(&observer, display, draw, attribute, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glXQueryDrawable() -- done");
    return _result_;
}
EXPORT HGLRC STDCALL wglCreateContext(HDC hdc) {
    Spy* s = Spy::get();
    GAPID_DEBUG("wglCreateContext(%p)", hdc);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "wglCreateContext");
    auto _result_ = s->wglCreateContext(&observer, hdc);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "wglCreateContextAttribsARB");
    auto _result_ = s->wglCreateContextAttribsARB(&observer, hdc, hShareContext, attribList);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "wglMakeCurrent");
    auto _result_ = s->wglMakeCurrent(&observer, hdc, hglrc);
    s->unlock();
    s->exit();
    GAPID_DEBUG("wglMakeCurrent() -- done");
    return _result_;
}
EXPORT void STDCALL wglSwapBuffers(HDC hdc) {
    Spy* s = Spy::get();
    GAPID_DEBUG("wglSwapBuffers(%p)", hdc);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "wglSwapBuffers");
    s->wglSwapBuffers(&observer, hdc);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "CGLCreateContext");
    auto _result_ = s->CGLCreateContext(&observer, pix, share, ctx);
    s->unlock();
    s->exit();
    GAPID_DEBUG("CGLCreateContext() -- done");
    return _result_;
}
EXPORT CGLError STDCALL CGLSetCurrentContext(CGLContextObj ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGLSetCurrentContext(%p)", ctx);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "CGLSetCurrentContext");
    auto _result_ = s->CGLSetCurrentContext(&observer, ctx);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "CGLGetSurface");
    auto _result_ = s->CGLGetSurface(&observer, ctx, cid, wid, sid);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "CGSGetSurfaceBounds");
    auto _result_ = s->CGSGetSurfaceBounds(&observer, cid, wid, sid, bounds);
    s->unlock();
    s->exit();
    GAPID_DEBUG("CGSGetSurfaceBounds() -- done");
    return _result_;
}
EXPORT CGLError STDCALL CGLFlushDrawable(CGLContextObj ctx) {
    Spy* s = Spy::get();
    GAPID_DEBUG("CGLFlushDrawable(%p)", ctx);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "CGLFlushDrawable");
    auto _result_ = s->CGLFlushDrawable(&observer, ctx);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjecti64v");
    s->glGetQueryObjecti64v(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetQueryObjectui64v");
    s->glGetQueryObjectui64v(&observer, query, parameter, value);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetQueryObjectui64v() -- done");
}
EXPORT void STDCALL glTexStorage1D(uint32_t target, GLsizei levels, uint32_t internalformat, GLsizei width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glTexStorage1D(%u, %" PRId32 ", %u, %" PRId32 ")", target, levels, internalformat, width);
    if (!s->try_to_enter()) {
        GAPID_INFO("glTexStorage1D at %p: GAPII re-entered. Just invoking imported function at %p", glTexStorage1D, s->GlesSpy::imports().glTexStorage1D);
        s->GlesSpy::imports().glTexStorage1D(target, levels, internalformat, width);
        GAPID_DEBUG("glTexStorage1D() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexStorage1D");
    s->glTexStorage1D(&observer, target, levels, internalformat, width);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glTexStorage1D() -- done");
}
EXPORT void STDCALL glBindFragDataLocation(ProgramId program, GLuint color, const char* name) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBindFragDataLocation(%" PRIu32 ", %" PRIu32 ", %s)", program, color, name);
    if (!s->try_to_enter()) {
        GAPID_INFO("glBindFragDataLocation at %p: GAPII re-entered. Just invoking imported function at %p", glBindFragDataLocation, s->GlesSpy::imports().glBindFragDataLocation);
        s->GlesSpy::imports().glBindFragDataLocation(program, color, name);
        GAPID_DEBUG("glBindFragDataLocation() -- done");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindFragDataLocation");
    s->glBindFragDataLocation(&observer, program, color, name);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindFragDataLocation() -- done");
}
EXPORT void STDCALL glAlphaFunc(uint32_t func, GLfloat ref) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glAlphaFunc(%u, %f)", func, ref);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glAlphaFunc");
    s->glAlphaFunc(&observer, func, ref);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glAlphaFuncx");
    s->glAlphaFuncx(&observer, func, ref);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glAlphaFuncxOES");
    s->glAlphaFuncxOES(&observer, func, ref);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindFramebufferOES");
    s->glBindFramebufferOES(&observer, target, framebuffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBindRenderbufferOES");
    s->glBindRenderbufferOES(&observer, target, renderbuffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBindRenderbufferOES() -- done");
}
EXPORT void STDCALL glBlendEquationOES(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glBlendEquationOES(%u)", mode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationOES");
    s->glBlendEquationOES(&observer, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendEquationSeparateOES");
    s->glBlendEquationSeparateOES(&observer, modeRGB, modeAlpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glBlendFuncSeparateOES");
    s->glBlendFuncSeparateOES(&observer, srcRGB, dstRGB, srcAlpha, dstAlpha);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glBlendFuncSeparateOES() -- done");
}
EXPORT uint32_t STDCALL glCheckFramebufferStatusOES(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCheckFramebufferStatusOES(%u)", target);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCheckFramebufferStatusOES");
    auto _result_ = s->glCheckFramebufferStatusOES(&observer, target);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearColorx");
    s->glClearColorx(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearColorxOES");
    s->glClearColorxOES(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearColorxOES() -- done");
}
EXPORT void STDCALL glClearDepthfOES(GLclampf depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthfOES(%f)", depth);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearDepthfOES");
    s->glClearDepthfOES(&observer, depth);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearDepthfOES() -- done");
}
EXPORT void STDCALL glClearDepthx(GLfixed depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthx(%" PRId32 ")", depth);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearDepthx");
    s->glClearDepthx(&observer, depth);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearDepthx() -- done");
}
EXPORT void STDCALL glClearDepthxOES(GLfixed depth) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClearDepthxOES(%" PRId32 ")", depth);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClearDepthxOES");
    s->glClearDepthxOES(&observer, depth);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glClearDepthxOES() -- done");
}
EXPORT void STDCALL glClientActiveTexture(uint32_t texture) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glClientActiveTexture(%u)", texture);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClientActiveTexture");
    s->glClientActiveTexture(&observer, texture);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClipPlanef");
    s->glClipPlanef(&observer, p, eqn);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClipPlanefIMG");
    s->glClipPlanefIMG(&observer, p, eqn);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClipPlanefOES");
    s->glClipPlanefOES(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClipPlanex");
    s->glClipPlanex(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClipPlanexIMG");
    s->glClipPlanexIMG(&observer, p, eqn);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glClipPlanexOES");
    s->glClipPlanexOES(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColor4f");
    s->glColor4f(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColor4ub");
    s->glColor4ub(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColor4x");
    s->glColor4x(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColor4xOES");
    s->glColor4xOES(&observer, red, green, blue, alpha);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColorPointer");
    s->glColorPointer(&observer, size, type, stride, pointer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glColorPointer() -- done");
}
EXPORT void STDCALL glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glCurrentPaletteMatrixOES(%" PRIu32 ")", matrixpaletteindex);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glCurrentPaletteMatrixOES");
    s->glCurrentPaletteMatrixOES(&observer, matrixpaletteindex);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteFramebuffersOES");
    s->glDeleteFramebuffersOES(&observer, n, framebuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDeleteRenderbuffersOES");
    s->glDeleteRenderbuffersOES(&observer, n, renderbuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangefOES");
    s->glDepthRangefOES(&observer, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangex");
    s->glDepthRangex(&observer, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDepthRangexOES");
    s->glDepthRangexOES(&observer, n, f);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDepthRangexOES() -- done");
}
EXPORT void STDCALL glDisableClientState(uint32_t array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDisableClientState(%u)", array);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDisableClientState");
    s->glDisableClientState(&observer, array);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexfOES");
    s->glDrawTexfOES(&observer, x, y, z, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTexfOES() -- done");
}
EXPORT void STDCALL glDrawTexfvOES(GLfloat* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexfvOES(%p)", coords);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexfvOES");
    s->glDrawTexfvOES(&observer, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexiOES");
    s->glDrawTexiOES(&observer, x, y, z, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTexiOES() -- done");
}
EXPORT void STDCALL glDrawTexivOES(GLint* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexivOES(%p)", coords);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexivOES");
    s->glDrawTexivOES(&observer, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexsOES");
    s->glDrawTexsOES(&observer, x, y, z, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTexsOES() -- done");
}
EXPORT void STDCALL glDrawTexsvOES(GLshort* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexsvOES(%p)", coords);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexsvOES");
    s->glDrawTexsvOES(&observer, coords);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexxOES");
    s->glDrawTexxOES(&observer, x, y, z, width, height);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTexxOES() -- done");
}
EXPORT void STDCALL glDrawTexxvOES(GLfixed* coords) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glDrawTexxvOES(%p)", coords);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glDrawTexxvOES");
    s->glDrawTexxvOES(&observer, coords);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glDrawTexxvOES() -- done");
}
EXPORT void STDCALL glEnableClientState(uint32_t array) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glEnableClientState(%u)", array);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glEnableClientState");
    s->glEnableClientState(&observer, array);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFogf");
    s->glFogf(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFogfv");
    s->glFogfv(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFogx");
    s->glFogx(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFogxOES");
    s->glFogxOES(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFogxv");
    s->glFogxv(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFogxvOES");
    s->glFogxvOES(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferRenderbufferOES");
    s->glFramebufferRenderbufferOES(&observer, target, attachment, renderbuffertarget, renderbuffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFramebufferTexture2DOES");
    s->glFramebufferTexture2DOES(&observer, target, attachment, textarget, texture, level);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFrustumf");
    s->glFrustumf(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFrustumfOES");
    s->glFrustumfOES(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFrustumx");
    s->glFrustumx(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glFrustumxOES");
    s->glFrustumxOES(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenFramebuffersOES");
    s->glGenFramebuffersOES(&observer, n, framebuffers);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenRenderbuffersOES");
    s->glGenRenderbuffersOES(&observer, n, renderbuffers);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGenRenderbuffersOES() -- done");
}
EXPORT void STDCALL glGenerateMipmapOES(uint32_t target) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glGenerateMipmapOES(%u)", target);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGenerateMipmapOES");
    s->glGenerateMipmapOES(&observer, target);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetClipPlanef");
    s->glGetClipPlanef(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetClipPlanefOES");
    s->glGetClipPlanefOES(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetClipPlanex");
    s->glGetClipPlanex(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetClipPlanexOES");
    s->glGetClipPlanexOES(&observer, plane, equation);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFixedv");
    s->glGetFixedv(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFixedvOES");
    s->glGetFixedvOES(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetFramebufferAttachmentParameterivOES");
    s->glGetFramebufferAttachmentParameterivOES(&observer, target, attachment, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetLightfv");
    s->glGetLightfv(&observer, light, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetLightxv");
    s->glGetLightxv(&observer, light, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetLightxvOES");
    s->glGetLightxvOES(&observer, light, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetMaterialfv");
    s->glGetMaterialfv(&observer, face, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetMaterialxv");
    s->glGetMaterialxv(&observer, face, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetMaterialxvOES");
    s->glGetMaterialxvOES(&observer, face, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetRenderbufferParameterivOES");
    s->glGetRenderbufferParameterivOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexEnvfv");
    s->glGetTexEnvfv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexEnviv");
    s->glGetTexEnviv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexEnvxv");
    s->glGetTexEnvxv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexEnvxvOES");
    s->glGetTexEnvxvOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexGenfvOES");
    s->glGetTexGenfvOES(&observer, coord, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexGenivOES");
    s->glGetTexGenivOES(&observer, coord, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexGenxvOES");
    s->glGetTexGenxvOES(&observer, coord, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterxv");
    s->glGetTexParameterxv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glGetTexParameterxvOES");
    s->glGetTexParameterxvOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glGetTexParameterxvOES() -- done");
}
EXPORT GLboolean STDCALL glIsFramebufferOES(GLuint framebuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsFramebufferOES(%" PRIu32 ")", framebuffer);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsFramebufferOES");
    auto _result_ = s->glIsFramebufferOES(&observer, framebuffer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glIsFramebufferOES() -- done");
    return _result_;
}
EXPORT GLboolean STDCALL glIsRenderbufferOES(GLuint renderbuffer) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glIsRenderbufferOES(%" PRIu32 ")", renderbuffer);
    if (!s->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glIsRenderbufferOES");
    auto _result_ = s->glIsRenderbufferOES(&observer, renderbuffer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightModelf");
    s->glLightModelf(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightModelfv");
    s->glLightModelfv(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightModelx");
    s->glLightModelx(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightModelxOES");
    s->glLightModelxOES(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightModelxv");
    s->glLightModelxv(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightModelxvOES");
    s->glLightModelxvOES(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightf");
    s->glLightf(&observer, light, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightfv");
    s->glLightfv(&observer, light, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightx");
    s->glLightx(&observer, light, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightxOES");
    s->glLightxOES(&observer, light, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightxv");
    s->glLightxv(&observer, light, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLightxvOES");
    s->glLightxvOES(&observer, light, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLightxvOES() -- done");
}
EXPORT void STDCALL glLineWidthx(GLfixed width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLineWidthx(%" PRId32 ")", width);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLineWidthx");
    s->glLineWidthx(&observer, width);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLineWidthx() -- done");
}
EXPORT void STDCALL glLineWidthxOES(GLfixed width) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLineWidthxOES(%" PRId32 ")", width);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLineWidthxOES");
    s->glLineWidthxOES(&observer, width);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLineWidthxOES() -- done");
}
EXPORT void STDCALL glLoadIdentity() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadIdentity()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLoadIdentity");
    s->glLoadIdentity(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLoadIdentity() -- done");
}
EXPORT void STDCALL glLoadMatrixf(GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadMatrixf(%p)", m);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLoadMatrixf");
    s->glLoadMatrixf(&observer, m);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLoadMatrixf() -- done");
}
EXPORT void STDCALL glLoadMatrixx(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadMatrixx(%p)", m);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLoadMatrixx");
    s->glLoadMatrixx(&observer, m);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLoadMatrixx() -- done");
}
EXPORT void STDCALL glLoadMatrixxOES(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadMatrixxOES(%p)", m);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLoadMatrixxOES");
    s->glLoadMatrixxOES(&observer, m);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLoadMatrixxOES() -- done");
}
EXPORT void STDCALL glLoadPaletteFromModelViewMatrixOES() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLoadPaletteFromModelViewMatrixOES()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLoadPaletteFromModelViewMatrixOES");
    s->glLoadPaletteFromModelViewMatrixOES(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glLoadPaletteFromModelViewMatrixOES() -- done");
}
EXPORT void STDCALL glLogicOp(uint32_t opcode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glLogicOp(%u)", opcode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glLogicOp");
    s->glLogicOp(&observer, opcode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMaterialf");
    s->glMaterialf(&observer, face, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMaterialfv");
    s->glMaterialfv(&observer, face, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMaterialx");
    s->glMaterialx(&observer, face, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMaterialxOES");
    s->glMaterialxOES(&observer, face, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMaterialxv");
    s->glMaterialxv(&observer, face, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMaterialxvOES");
    s->glMaterialxvOES(&observer, face, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixIndexPointerOES");
    s->glMatrixIndexPointerOES(&observer, size, type, stride, pointer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMatrixIndexPointerOES() -- done");
}
EXPORT void STDCALL glMatrixMode(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMatrixMode(%u)", mode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixMode");
    s->glMatrixMode(&observer, mode);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMatrixMode() -- done");
}
EXPORT void STDCALL glMultMatrixf(GLfloat* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultMatrixf(%p)", m);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultMatrixf");
    s->glMultMatrixf(&observer, m);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMultMatrixf() -- done");
}
EXPORT void STDCALL glMultMatrixx(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultMatrixx(%p)", m);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultMatrixx");
    s->glMultMatrixx(&observer, m);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glMultMatrixx() -- done");
}
EXPORT void STDCALL glMultMatrixxOES(GLfixed* m) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glMultMatrixxOES(%p)", m);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultMatrixxOES");
    s->glMultMatrixxOES(&observer, m);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiTexCoord4f");
    s->glMultiTexCoord4f(&observer, target, v0, v1, v2, v3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiTexCoord4x");
    s->glMultiTexCoord4x(&observer, texture, v0, v1, v2, v3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMultiTexCoord4xOES");
    s->glMultiTexCoord4xOES(&observer, texture, v0, v1, v2, v3);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glNormal3f");
    s->glNormal3f(&observer, nx, ny, nz);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glNormal3x");
    s->glNormal3x(&observer, nx, ny, nz);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glNormal3xOES");
    s->glNormal3xOES(&observer, nx, ny, nz);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glNormalPointer");
    s->glNormalPointer(&observer, type, stride, pointer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glOrthof");
    s->glOrthof(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glOrthofOES");
    s->glOrthofOES(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glOrthox");
    s->glOrthox(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glOrthoxOES");
    s->glOrthoxOES(&observer, l, r, b, t, n, f);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointParameterf");
    s->glPointParameterf(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointParameterfv");
    s->glPointParameterfv(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointParameterx");
    s->glPointParameterx(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointParameterxOES");
    s->glPointParameterxOES(&observer, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointParameterxv");
    s->glPointParameterxv(&observer, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointParameterxvOES");
    s->glPointParameterxvOES(&observer, pname, params);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPointParameterxvOES() -- done");
}
EXPORT void STDCALL glPointSize(GLfloat size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSize(%f)", size);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointSize");
    s->glPointSize(&observer, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointSizePointerOES");
    s->glPointSizePointerOES(&observer, type, stride, pointer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPointSizePointerOES() -- done");
}
EXPORT void STDCALL glPointSizex(GLfixed size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSizex(%" PRId32 ")", size);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointSizex");
    s->glPointSizex(&observer, size);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPointSizex() -- done");
}
EXPORT void STDCALL glPointSizexOES(GLfixed size) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPointSizexOES(%" PRId32 ")", size);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointSizexOES");
    s->glPointSizexOES(&observer, size);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPolygonOffsetx");
    s->glPolygonOffsetx(&observer, factor, units);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPolygonOffsetxOES");
    s->glPolygonOffsetxOES(&observer, factor, units);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPolygonOffsetxOES() -- done");
}
EXPORT void STDCALL glPopMatrix() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPopMatrix()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPopMatrix");
    s->glPopMatrix(&observer);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glPopMatrix() -- done");
}
EXPORT void STDCALL glPushMatrix() {
    Spy* s = Spy::get();
    GAPID_DEBUG("glPushMatrix()");
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPushMatrix");
    s->glPushMatrix(&observer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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_;
    }
    CallObserver observer(s);
    s->lock(&observer, "glQueryMatrixxOES");
    auto _result_ = s->glQueryMatrixxOES(&observer, mantissa, exponent);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRenderbufferStorageOES");
    s->glRenderbufferStorageOES(&observer, target, internalformat, width, height);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRotatef");
    s->glRotatef(&observer, angle, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRotatex");
    s->glRotatex(&observer, angle, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glRotatexOES");
    s->glRotatexOES(&observer, angle, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSampleCoveragex");
    s->glSampleCoveragex(&observer, value, invert);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glSampleCoveragexOES");
    s->glSampleCoveragexOES(&observer, value, invert);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScalef");
    s->glScalef(&observer, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScalex");
    s->glScalex(&observer, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glScalexOES");
    s->glScalexOES(&observer, x, y, z);
    s->unlock();
    s->exit();
    GAPID_DEBUG("glScalexOES() -- done");
}
EXPORT void STDCALL glShadeModel(uint32_t mode) {
    Spy* s = Spy::get();
    GAPID_DEBUG("glShadeModel(%u)", mode);
    if (!s->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glShadeModel");
    s->glShadeModel(&observer, mode);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexCoordPointer");
    s->glTexCoordPointer(&observer, size, type, stride, pointer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvf");
    s->glTexEnvf(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvfv");
    s->glTexEnvfv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvi");
    s->glTexEnvi(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnviv");
    s->glTexEnviv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvx");
    s->glTexEnvx(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvxOES");
    s->glTexEnvxOES(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvxv");
    s->glTexEnvxv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexEnvxvOES");
    s->glTexEnvxvOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexGenfOES");
    s->glTexGenfOES(&observer, coord, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexGenfvOES");
    s->glTexGenfvOES(&observer, coord, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexGeniOES");
    s->glTexGeniOES(&observer, coord, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexGenivOES");
    s->glTexGenivOES(&observer, coord, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexGenxOES");
    s->glTexGenxOES(&observer, coord, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexGenxvOES");
    s->glTexGenxvOES(&observer, coord, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterx");
    s->glTexParameterx(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterxOES");
    s->glTexParameterxOES(&observer, target, pname, param);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterxv");
    s->glTexParameterxv(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexParameterxvOES");
    s->glTexParameterxvOES(&observer, target, pname, params);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTranslatef");
    s->glTranslatef(&observer, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTranslatex");
    s->glTranslatex(&observer, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTranslatexOES");
    s->glTranslatexOES(&observer, x, y, z);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexPointer");
    s->glVertexPointer(&observer, size, type, stride, pointer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glWeightPointerOES");
    s->glWeightPointerOES(&observer, size, type, stride, pointer);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glColorPointerBounds");
    s->glColorPointerBounds(&observer, size, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glNormalPointerBounds");
    s->glNormalPointerBounds(&observer, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glTexCoordPointerBounds");
    s->glTexCoordPointerBounds(&observer, size, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glVertexPointerBounds");
    s->glVertexPointerBounds(&observer, size, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glPointSizePointerOESBounds");
    s->glPointSizePointerOESBounds(&observer, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glMatrixIndexPointerOESBounds");
    s->glMatrixIndexPointerOESBounds(&observer, size, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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->try_to_enter()) {
        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");
        return;
    }
    CallObserver observer(s);
    s->lock(&observer, "glWeightPointerOESBounds");
    s->glWeightPointerOESBounds(&observer, size, type, stride, pointer, count);
    s->unlock();
    s->exit();
    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"