cc/gapir/gfx_api.cpp

////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////



#include "gfx_api.h"
#include "interpreter.h"
#include "stack.h"

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

#define __STDC_FORMAT_MACROS
#include <inttypes.h>

namespace gapir {

    const char* Gles::ID = "Gles";

    Gles::Gles() {
        using namespace std::placeholders;

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

        mFunctions.insert(0, std::bind(&Gles::callGlBlendBarrierKHR, this, _1, _2));
        mFunctions.insert(1, std::bind(&Gles::callGlBlendEquationSeparateiEXT, this, _1, _2));
        mFunctions.insert(2, std::bind(&Gles::callGlBlendEquationiEXT, this, _1, _2));
        mFunctions.insert(3, std::bind(&Gles::callGlBlendFuncSeparateiEXT, this, _1, _2));
        mFunctions.insert(4, std::bind(&Gles::callGlBlendFunciEXT, this, _1, _2));
        mFunctions.insert(5, std::bind(&Gles::callGlColorMaskiEXT, this, _1, _2));
        mFunctions.insert(6, std::bind(&Gles::callGlCopyImageSubDataEXT, this, _1, _2));
        mFunctions.insert(7, std::bind(&Gles::callGlDebugMessageCallbackKHR, this, _1, _2));
        mFunctions.insert(8, std::bind(&Gles::callGlDebugMessageControlKHR, this, _1, _2));
        mFunctions.insert(9, std::bind(&Gles::callGlDebugMessageInsertKHR, this, _1, _2));
        mFunctions.insert(10, std::bind(&Gles::callGlDisableiEXT, this, _1, _2));
        mFunctions.insert(11, std::bind(&Gles::callGlEnableiEXT, this, _1, _2));
        mFunctions.insert(12, std::bind(&Gles::callGlFramebufferTextureEXT, this, _1, _2));
        mFunctions.insert(13, std::bind(&Gles::callGlGetDebugMessageLogKHR, this, _1, _2));
        mFunctions.insert(14, std::bind(&Gles::callGlGetObjectLabelKHR, this, _1, _2));
        mFunctions.insert(15, std::bind(&Gles::callGlGetObjectPtrLabelKHR, this, _1, _2));
        mFunctions.insert(16, std::bind(&Gles::callGlGetPointervKHR, this, _1, _2));
        mFunctions.insert(17, std::bind(&Gles::callGlGetSamplerParameterIivEXT, this, _1, _2));
        mFunctions.insert(18, std::bind(&Gles::callGlGetSamplerParameterIuivEXT, this, _1, _2));
        mFunctions.insert(19, std::bind(&Gles::callGlGetTexParameterIivEXT, this, _1, _2));
        mFunctions.insert(20, std::bind(&Gles::callGlGetTexParameterIuivEXT, this, _1, _2));
        mFunctions.insert(21, std::bind(&Gles::callGlIsEnablediEXT, this, _1, _2));
        mFunctions.insert(22, std::bind(&Gles::callGlMinSampleShadingOES, this, _1, _2));
        mFunctions.insert(23, std::bind(&Gles::callGlObjectLabelKHR, this, _1, _2));
        mFunctions.insert(24, std::bind(&Gles::callGlObjectPtrLabelKHR, this, _1, _2));
        mFunctions.insert(25, std::bind(&Gles::callGlPatchParameteriEXT, this, _1, _2));
        mFunctions.insert(26, std::bind(&Gles::callGlPopDebugGroupKHR, this, _1, _2));
        mFunctions.insert(27, std::bind(&Gles::callGlPrimitiveBoundingBoxEXT, this, _1, _2));
        mFunctions.insert(28, std::bind(&Gles::callGlPushDebugGroupKHR, this, _1, _2));
        mFunctions.insert(29, std::bind(&Gles::callGlSamplerParameterIivEXT, this, _1, _2));
        mFunctions.insert(30, std::bind(&Gles::callGlSamplerParameterIuivEXT, this, _1, _2));
        mFunctions.insert(31, std::bind(&Gles::callGlTexBufferEXT, this, _1, _2));
        mFunctions.insert(32, std::bind(&Gles::callGlTexBufferRangeEXT, this, _1, _2));
        mFunctions.insert(33, std::bind(&Gles::callGlTexParameterIivEXT, this, _1, _2));
        mFunctions.insert(34, std::bind(&Gles::callGlTexParameterIuivEXT, this, _1, _2));
        mFunctions.insert(35, std::bind(&Gles::callGlTexStorage3DMultisampleOES, this, _1, _2));
        mFunctions.insert(36, std::bind(&Gles::callGlBeginQuery, this, _1, _2));
        mFunctions.insert(37, std::bind(&Gles::callGlDeleteQueries, this, _1, _2));
        mFunctions.insert(38, std::bind(&Gles::callGlEndQuery, this, _1, _2));
        mFunctions.insert(39, std::bind(&Gles::callGlGenQueries, this, _1, _2));
        mFunctions.insert(40, std::bind(&Gles::callGlGetQueryObjectuiv, this, _1, _2));
        mFunctions.insert(41, std::bind(&Gles::callGlGetQueryiv, this, _1, _2));
        mFunctions.insert(42, std::bind(&Gles::callGlIsQuery, this, _1, _2));
        mFunctions.insert(43, std::bind(&Gles::callGlBindBuffer, this, _1, _2));
        mFunctions.insert(44, std::bind(&Gles::callGlBindBufferBase, this, _1, _2));
        mFunctions.insert(45, std::bind(&Gles::callGlBindBufferRange, this, _1, _2));
        mFunctions.insert(46, std::bind(&Gles::callGlBufferData, this, _1, _2));
        mFunctions.insert(47, std::bind(&Gles::callGlBufferSubData, this, _1, _2));
        mFunctions.insert(48, std::bind(&Gles::callGlCopyBufferSubData, this, _1, _2));
        mFunctions.insert(49, std::bind(&Gles::callGlDeleteBuffers, this, _1, _2));
        mFunctions.insert(50, std::bind(&Gles::callGlGenBuffers, this, _1, _2));
        mFunctions.insert(51, std::bind(&Gles::callGlGetBufferParameteri64v, this, _1, _2));
        mFunctions.insert(52, std::bind(&Gles::callGlGetBufferParameteriv, this, _1, _2));
        mFunctions.insert(53, std::bind(&Gles::callGlGetBufferPointerv, this, _1, _2));
        mFunctions.insert(54, std::bind(&Gles::callGlIsBuffer, this, _1, _2));
        mFunctions.insert(55, std::bind(&Gles::callGlMapBufferRange, this, _1, _2));
        mFunctions.insert(56, std::bind(&Gles::callGlUnmapBuffer, this, _1, _2));
        mFunctions.insert(57, std::bind(&Gles::callGlDebugMessageCallback, this, _1, _2));
        mFunctions.insert(58, std::bind(&Gles::callGlDebugMessageControl, this, _1, _2));
        mFunctions.insert(59, std::bind(&Gles::callGlDebugMessageInsert, this, _1, _2));
        mFunctions.insert(60, std::bind(&Gles::callGlGetDebugMessageLog, this, _1, _2));
        mFunctions.insert(61, std::bind(&Gles::callGlGetObjectLabel, this, _1, _2));
        mFunctions.insert(62, std::bind(&Gles::callGlGetObjectPtrLabel, this, _1, _2));
        mFunctions.insert(63, std::bind(&Gles::callGlGetPointerv, this, _1, _2));
        mFunctions.insert(64, std::bind(&Gles::callGlObjectLabel, this, _1, _2));
        mFunctions.insert(65, std::bind(&Gles::callGlObjectPtrLabel, this, _1, _2));
        mFunctions.insert(66, std::bind(&Gles::callGlPopDebugGroup, this, _1, _2));
        mFunctions.insert(67, std::bind(&Gles::callGlPushDebugGroup, this, _1, _2));
        mFunctions.insert(68, std::bind(&Gles::callGlDrawArrays, this, _1, _2));
        mFunctions.insert(69, std::bind(&Gles::callGlDrawArraysIndirect, this, _1, _2));
        mFunctions.insert(70, std::bind(&Gles::callGlDrawArraysInstanced, this, _1, _2));
        mFunctions.insert(71, std::bind(&Gles::callGlDrawElements, this, _1, _2));
        mFunctions.insert(72, std::bind(&Gles::callGlDrawElementsBaseVertex, this, _1, _2));
        mFunctions.insert(73, std::bind(&Gles::callGlDrawElementsIndirect, this, _1, _2));
        mFunctions.insert(74, std::bind(&Gles::callGlDrawElementsInstanced, this, _1, _2));
        mFunctions.insert(75, std::bind(&Gles::callGlDrawElementsInstancedBaseVertex, this, _1, _2));
        mFunctions.insert(76, std::bind(&Gles::callGlDrawRangeElements, this, _1, _2));
        mFunctions.insert(77, std::bind(&Gles::callGlDrawRangeElementsBaseVertex, this, _1, _2));
        mFunctions.insert(78, std::bind(&Gles::callGlPatchParameteri, this, _1, _2));
        mFunctions.insert(79, std::bind(&Gles::callGlPrimitiveBoundingBox, this, _1, _2));
        mFunctions.insert(80, std::bind(&Gles::callGlActiveShaderProgramEXT, this, _1, _2));
        mFunctions.insert(81, std::bind(&Gles::callGlAlphaFuncQCOM, this, _1, _2));
        mFunctions.insert(82, std::bind(&Gles::callGlApplyFramebufferAttachmentCMAAINTEL, this, _1, _2));
        mFunctions.insert(83, std::bind(&Gles::callGlBeginConditionalRenderNV, this, _1, _2));
        mFunctions.insert(84, std::bind(&Gles::callGlBeginPerfMonitorAMD, this, _1, _2));
        mFunctions.insert(85, std::bind(&Gles::callGlBeginPerfQueryINTEL, this, _1, _2));
        mFunctions.insert(86, std::bind(&Gles::callGlBeginQueryEXT, this, _1, _2));
        mFunctions.insert(87, std::bind(&Gles::callGlBindFragDataLocationEXT, this, _1, _2));
        mFunctions.insert(88, std::bind(&Gles::callGlBindFragDataLocationIndexedEXT, this, _1, _2));
        mFunctions.insert(89, std::bind(&Gles::callGlBindProgramPipelineEXT, this, _1, _2));
        mFunctions.insert(90, std::bind(&Gles::callGlBindVertexArrayOES, this, _1, _2));
        mFunctions.insert(91, std::bind(&Gles::callGlBlendBarrierNV, this, _1, _2));
        mFunctions.insert(92, std::bind(&Gles::callGlBlendEquationSeparateiOES, this, _1, _2));
        mFunctions.insert(93, std::bind(&Gles::callGlBlendEquationiOES, this, _1, _2));
        mFunctions.insert(94, std::bind(&Gles::callGlBlendFuncSeparateiOES, this, _1, _2));
        mFunctions.insert(95, std::bind(&Gles::callGlBlendFunciOES, this, _1, _2));
        mFunctions.insert(96, std::bind(&Gles::callGlBlendParameteriNV, this, _1, _2));
        mFunctions.insert(97, std::bind(&Gles::callGlBlitFramebufferANGLE, this, _1, _2));
        mFunctions.insert(98, std::bind(&Gles::callGlBlitFramebufferNV, this, _1, _2));
        mFunctions.insert(99, std::bind(&Gles::callGlBufferStorageEXT, this, _1, _2));
        mFunctions.insert(100, std::bind(&Gles::callGlClientWaitSyncAPPLE, this, _1, _2));
        mFunctions.insert(101, std::bind(&Gles::callGlColorMaskiOES, this, _1, _2));
        mFunctions.insert(102, std::bind(&Gles::callGlCompressedTexImage3DOES, this, _1, _2));
        mFunctions.insert(103, std::bind(&Gles::callGlCompressedTexSubImage3DOES, this, _1, _2));
        mFunctions.insert(104, std::bind(&Gles::callGlCopyBufferSubDataNV, this, _1, _2));
        mFunctions.insert(105, std::bind(&Gles::callGlCopyImageSubDataOES, this, _1, _2));
        mFunctions.insert(106, std::bind(&Gles::callGlCopyPathNV, this, _1, _2));
        mFunctions.insert(107, std::bind(&Gles::callGlCopyTexSubImage3DOES, this, _1, _2));
        mFunctions.insert(108, std::bind(&Gles::callGlCopyTextureLevelsAPPLE, this, _1, _2));
        mFunctions.insert(109, std::bind(&Gles::callGlCoverFillPathInstancedNV, this, _1, _2));
        mFunctions.insert(110, std::bind(&Gles::callGlCoverFillPathNV, this, _1, _2));
        mFunctions.insert(111, std::bind(&Gles::callGlCoverStrokePathInstancedNV, this, _1, _2));
        mFunctions.insert(112, std::bind(&Gles::callGlCoverStrokePathNV, this, _1, _2));
        mFunctions.insert(113, std::bind(&Gles::callGlCoverageMaskNV, this, _1, _2));
        mFunctions.insert(114, std::bind(&Gles::callGlCoverageModulationNV, this, _1, _2));
        mFunctions.insert(115, std::bind(&Gles::callGlCoverageModulationTableNV, this, _1, _2));
        mFunctions.insert(116, std::bind(&Gles::callGlCoverageOperationNV, this, _1, _2));
        mFunctions.insert(117, std::bind(&Gles::callGlCreatePerfQueryINTEL, this, _1, _2));
        mFunctions.insert(118, std::bind(&Gles::callGlCreateShaderProgramvEXT, this, _1, _2));
        mFunctions.insert(119, std::bind(&Gles::callGlDeleteFencesNV, this, _1, _2));
        mFunctions.insert(120, std::bind(&Gles::callGlDeletePathsNV, this, _1, _2));
        mFunctions.insert(121, std::bind(&Gles::callGlDeletePerfMonitorsAMD, this, _1, _2));
        mFunctions.insert(122, std::bind(&Gles::callGlDeletePerfQueryINTEL, this, _1, _2));
        mFunctions.insert(123, std::bind(&Gles::callGlDeleteProgramPipelinesEXT, this, _1, _2));
        mFunctions.insert(124, std::bind(&Gles::callGlDeleteQueriesEXT, this, _1, _2));
        mFunctions.insert(125, std::bind(&Gles::callGlDeleteSyncAPPLE, this, _1, _2));
        mFunctions.insert(126, std::bind(&Gles::callGlDeleteVertexArraysOES, this, _1, _2));
        mFunctions.insert(127, std::bind(&Gles::callGlDepthRangeArrayfvNV, this, _1, _2));
        mFunctions.insert(128, std::bind(&Gles::callGlDepthRangeIndexedfNV, this, _1, _2));
        mFunctions.insert(129, std::bind(&Gles::callGlDisableDriverControlQCOM, this, _1, _2));
        mFunctions.insert(130, std::bind(&Gles::callGlDisableiNV, this, _1, _2));
        mFunctions.insert(131, std::bind(&Gles::callGlDisableiOES, this, _1, _2));
        mFunctions.insert(132, std::bind(&Gles::callGlDiscardFramebufferEXT, this, _1, _2));
        mFunctions.insert(133, std::bind(&Gles::callGlDrawArraysInstancedANGLE, this, _1, _2));
        mFunctions.insert(134, std::bind(&Gles::callGlDrawArraysInstancedBaseInstanceEXT, this, _1, _2));
        mFunctions.insert(135, std::bind(&Gles::callGlDrawArraysInstancedEXT, this, _1, _2));
        mFunctions.insert(136, std::bind(&Gles::callGlDrawArraysInstancedNV, this, _1, _2));
        mFunctions.insert(137, std::bind(&Gles::callGlDrawBuffersEXT, this, _1, _2));
        mFunctions.insert(138, std::bind(&Gles::callGlDrawBuffersIndexedEXT, this, _1, _2));
        mFunctions.insert(139, std::bind(&Gles::callGlDrawBuffersNV, this, _1, _2));
        mFunctions.insert(140, std::bind(&Gles::callGlDrawElementsBaseVertexEXT, this, _1, _2));
        mFunctions.insert(141, std::bind(&Gles::callGlDrawElementsBaseVertexOES, this, _1, _2));
        mFunctions.insert(142, std::bind(&Gles::callGlDrawElementsInstancedANGLE, this, _1, _2));
        mFunctions.insert(143, std::bind(&Gles::callGlDrawElementsInstancedBaseInstanceEXT, this, _1, _2));
        mFunctions.insert(144, std::bind(&Gles::callGlDrawElementsInstancedBaseVertexBaseInstanceEXT, this, _1, _2));
        mFunctions.insert(145, std::bind(&Gles::callGlDrawElementsInstancedBaseVertexEXT, this, _1, _2));
        mFunctions.insert(146, std::bind(&Gles::callGlDrawElementsInstancedBaseVertexOES, this, _1, _2));
        mFunctions.insert(147, std::bind(&Gles::callGlDrawElementsInstancedEXT, this, _1, _2));
        mFunctions.insert(148, std::bind(&Gles::callGlDrawElementsInstancedNV, this, _1, _2));
        mFunctions.insert(149, std::bind(&Gles::callGlDrawRangeElementsBaseVertexEXT, this, _1, _2));
        mFunctions.insert(150, std::bind(&Gles::callGlDrawRangeElementsBaseVertexOES, this, _1, _2));
        mFunctions.insert(151, std::bind(&Gles::callGlEGLImageTargetRenderbufferStorageOES, this, _1, _2));
        mFunctions.insert(152, std::bind(&Gles::callGlEGLImageTargetTexture2DOES, this, _1, _2));
        mFunctions.insert(153, std::bind(&Gles::callGlEnableDriverControlQCOM, this, _1, _2));
        mFunctions.insert(154, std::bind(&Gles::callGlEnableiNV, this, _1, _2));
        mFunctions.insert(155, std::bind(&Gles::callGlEnableiOES, this, _1, _2));
        mFunctions.insert(156, std::bind(&Gles::callGlEndConditionalRenderNV, this, _1, _2));
        mFunctions.insert(157, std::bind(&Gles::callGlEndPerfMonitorAMD, this, _1, _2));
        mFunctions.insert(158, std::bind(&Gles::callGlEndPerfQueryINTEL, this, _1, _2));
        mFunctions.insert(159, std::bind(&Gles::callGlEndQueryEXT, this, _1, _2));
        mFunctions.insert(160, std::bind(&Gles::callGlEndTilingQCOM, this, _1, _2));
        mFunctions.insert(161, std::bind(&Gles::callGlExtGetBufferPointervQCOM, this, _1, _2));
        mFunctions.insert(162, std::bind(&Gles::callGlExtGetBuffersQCOM, this, _1, _2));
        mFunctions.insert(163, std::bind(&Gles::callGlExtGetFramebuffersQCOM, this, _1, _2));
        mFunctions.insert(164, std::bind(&Gles::callGlExtGetProgramBinarySourceQCOM, this, _1, _2));
        mFunctions.insert(165, std::bind(&Gles::callGlExtGetProgramsQCOM, this, _1, _2));
        mFunctions.insert(166, std::bind(&Gles::callGlExtGetRenderbuffersQCOM, this, _1, _2));
        mFunctions.insert(167, std::bind(&Gles::callGlExtGetShadersQCOM, this, _1, _2));
        mFunctions.insert(168, std::bind(&Gles::callGlExtGetTexLevelParameterivQCOM, this, _1, _2));
        mFunctions.insert(169, std::bind(&Gles::callGlExtGetTexSubImageQCOM, this, _1, _2));
        mFunctions.insert(170, std::bind(&Gles::callGlExtGetTexturesQCOM, this, _1, _2));
        mFunctions.insert(171, std::bind(&Gles::callGlExtIsProgramBinaryQCOM, this, _1, _2));
        mFunctions.insert(172, std::bind(&Gles::callGlExtTexObjectStateOverrideiQCOM, this, _1, _2));
        mFunctions.insert(173, std::bind(&Gles::callGlFenceSyncAPPLE, this, _1, _2));
        mFunctions.insert(174, std::bind(&Gles::callGlFinishFenceNV, this, _1, _2));
        mFunctions.insert(175, std::bind(&Gles::callGlFlushMappedBufferRangeEXT, this, _1, _2));
        mFunctions.insert(176, std::bind(&Gles::callGlFragmentCoverageColorNV, this, _1, _2));
        mFunctions.insert(177, std::bind(&Gles::callGlFramebufferSampleLocationsfvNV, this, _1, _2));
        mFunctions.insert(178, std::bind(&Gles::callGlFramebufferTexture2DMultisampleEXT, this, _1, _2));
        mFunctions.insert(179, std::bind(&Gles::callGlFramebufferTexture2DMultisampleIMG, this, _1, _2));
        mFunctions.insert(180, std::bind(&Gles::callGlFramebufferTexture3DOES, this, _1, _2));
        mFunctions.insert(181, std::bind(&Gles::callGlFramebufferTextureMultiviewOVR, this, _1, _2));
        mFunctions.insert(182, std::bind(&Gles::callGlFramebufferTextureOES, this, _1, _2));
        mFunctions.insert(183, std::bind(&Gles::callGlGenFencesNV, this, _1, _2));
        mFunctions.insert(184, std::bind(&Gles::callGlGenPathsNV, this, _1, _2));
        mFunctions.insert(185, std::bind(&Gles::callGlGenPerfMonitorsAMD, this, _1, _2));
        mFunctions.insert(186, std::bind(&Gles::callGlGenProgramPipelinesEXT, this, _1, _2));
        mFunctions.insert(187, std::bind(&Gles::callGlGenQueriesEXT, this, _1, _2));
        mFunctions.insert(188, std::bind(&Gles::callGlGenVertexArraysOES, this, _1, _2));
        mFunctions.insert(189, std::bind(&Gles::callGlGetBufferPointervOES, this, _1, _2));
        mFunctions.insert(190, std::bind(&Gles::callGlGetCoverageModulationTableNV, this, _1, _2));
        mFunctions.insert(191, std::bind(&Gles::callGlGetDriverControlStringQCOM, this, _1, _2));
        mFunctions.insert(192, std::bind(&Gles::callGlGetDriverControlsQCOM, this, _1, _2));
        mFunctions.insert(193, std::bind(&Gles::callGlGetFenceivNV, this, _1, _2));
        mFunctions.insert(194, std::bind(&Gles::callGlGetFirstPerfQueryIdINTEL, this, _1, _2));
        mFunctions.insert(195, std::bind(&Gles::callGlGetFloatiVNV, this, _1, _2));
        mFunctions.insert(196, std::bind(&Gles::callGlGetFragDataIndexEXT, this, _1, _2));
        mFunctions.insert(197, std::bind(&Gles::callGlGetGraphicsResetStatusEXT, this, _1, _2));
        mFunctions.insert(198, std::bind(&Gles::callGlGetGraphicsResetStatusKHR, this, _1, _2));
        mFunctions.insert(199, std::bind(&Gles::callGlGetImageHandleNV, this, _1, _2));
        mFunctions.insert(200, std::bind(&Gles::callGlGetInteger64vAPPLE, this, _1, _2));
        mFunctions.insert(201, std::bind(&Gles::callGlGetIntegeriVEXT, this, _1, _2));
        mFunctions.insert(202, std::bind(&Gles::callGlGetInternalformatSampleivNV, this, _1, _2));
        mFunctions.insert(203, std::bind(&Gles::callGlGetNextPerfQueryIdINTEL, this, _1, _2));
        mFunctions.insert(204, std::bind(&Gles::callGlGetObjectLabelEXT, this, _1, _2));
        mFunctions.insert(205, std::bind(&Gles::callGlGetPathCommandsNV, this, _1, _2));
        mFunctions.insert(206, std::bind(&Gles::callGlGetPathCoordsNV, this, _1, _2));
        mFunctions.insert(207, std::bind(&Gles::callGlGetPathDashArrayNV, this, _1, _2));
        mFunctions.insert(208, std::bind(&Gles::callGlGetPathLengthNV, this, _1, _2));
        mFunctions.insert(209, std::bind(&Gles::callGlGetPathMetricRangeNV, this, _1, _2));
        mFunctions.insert(210, std::bind(&Gles::callGlGetPathMetricsNV, this, _1, _2));
        mFunctions.insert(211, std::bind(&Gles::callGlGetPathParameterfvNV, this, _1, _2));
        mFunctions.insert(212, std::bind(&Gles::callGlGetPathParameterivNV, this, _1, _2));
        mFunctions.insert(213, std::bind(&Gles::callGlGetPathSpacingNV, this, _1, _2));
        mFunctions.insert(214, std::bind(&Gles::callGlGetPerfCounterInfoINTEL, this, _1, _2));
        mFunctions.insert(215, std::bind(&Gles::callGlGetPerfMonitorCounterDataAMD, this, _1, _2));
        mFunctions.insert(216, std::bind(&Gles::callGlGetPerfMonitorCounterInfoAMD, this, _1, _2));
        mFunctions.insert(217, std::bind(&Gles::callGlGetPerfMonitorCounterStringAMD, this, _1, _2));
        mFunctions.insert(218, std::bind(&Gles::callGlGetPerfMonitorCountersAMD, this, _1, _2));
        mFunctions.insert(219, std::bind(&Gles::callGlGetPerfMonitorGroupStringAMD, this, _1, _2));
        mFunctions.insert(220, std::bind(&Gles::callGlGetPerfMonitorGroupsAMD, this, _1, _2));
        mFunctions.insert(221, std::bind(&Gles::callGlGetPerfQueryDataINTEL, this, _1, _2));
        mFunctions.insert(222, std::bind(&Gles::callGlGetPerfQueryIdByNameINTEL, this, _1, _2));
        mFunctions.insert(223, std::bind(&Gles::callGlGetPerfQueryInfoINTEL, this, _1, _2));
        mFunctions.insert(224, std::bind(&Gles::callGlGetProgramBinaryOES, this, _1, _2));
        mFunctions.insert(225, std::bind(&Gles::callGlGetProgramPipelineInfoLogEXT, this, _1, _2));
        mFunctions.insert(226, std::bind(&Gles::callGlGetProgramPipelineivEXT, this, _1, _2));
        mFunctions.insert(227, std::bind(&Gles::callGlGetProgramResourceLocationIndexEXT, this, _1, _2));
        mFunctions.insert(228, std::bind(&Gles::callGlGetProgramResourcefvNV, this, _1, _2));
        mFunctions.insert(229, std::bind(&Gles::callGlGetQueryObjecti64vEXT, this, _1, _2));
        mFunctions.insert(230, std::bind(&Gles::callGlGetQueryObjectivEXT, this, _1, _2));
        mFunctions.insert(231, std::bind(&Gles::callGlGetQueryObjectui64vEXT, this, _1, _2));
        mFunctions.insert(232, std::bind(&Gles::callGlGetQueryObjectuivEXT, this, _1, _2));
        mFunctions.insert(233, std::bind(&Gles::callGlGetQueryivEXT, this, _1, _2));
        mFunctions.insert(234, std::bind(&Gles::callGlGetSamplerParameterIivOES, this, _1, _2));
        mFunctions.insert(235, std::bind(&Gles::callGlGetSamplerParameterIuivOES, this, _1, _2));
        mFunctions.insert(236, std::bind(&Gles::callGlGetSyncivAPPLE, this, _1, _2));
        mFunctions.insert(237, std::bind(&Gles::callGlGetTexParameterIivOES, this, _1, _2));
        mFunctions.insert(238, std::bind(&Gles::callGlGetTexParameterIuivOES, this, _1, _2));
        mFunctions.insert(239, std::bind(&Gles::callGlGetTextureHandleNV, this, _1, _2));
        mFunctions.insert(240, std::bind(&Gles::callGlGetTextureSamplerHandleNV, this, _1, _2));
        mFunctions.insert(241, std::bind(&Gles::callGlGetTranslatedShaderSourceANGLE, this, _1, _2));
        mFunctions.insert(242, std::bind(&Gles::callGlGetnUniformfvEXT, this, _1, _2));
        mFunctions.insert(243, std::bind(&Gles::callGlGetnUniformfvKHR, this, _1, _2));
        mFunctions.insert(244, std::bind(&Gles::callGlGetnUniformivEXT, this, _1, _2));
        mFunctions.insert(245, std::bind(&Gles::callGlGetnUniformivKHR, this, _1, _2));
        mFunctions.insert(246, std::bind(&Gles::callGlGetnUniformuivKHR, this, _1, _2));
        mFunctions.insert(247, std::bind(&Gles::callGlInsertEventMarkerEXT, this, _1, _2));
        mFunctions.insert(248, std::bind(&Gles::callGlInterpolatePathsNV, this, _1, _2));
        mFunctions.insert(249, std::bind(&Gles::callGlIsEnablediNV, this, _1, _2));
        mFunctions.insert(250, std::bind(&Gles::callGlIsEnablediOES, this, _1, _2));
        mFunctions.insert(251, std::bind(&Gles::callGlIsFenceNV, this, _1, _2));
        mFunctions.insert(252, std::bind(&Gles::callGlIsImageHandleResidentNV, this, _1, _2));
        mFunctions.insert(253, std::bind(&Gles::callGlIsPathNV, this, _1, _2));
        mFunctions.insert(254, std::bind(&Gles::callGlIsPointInFillPathNV, this, _1, _2));
        mFunctions.insert(255, std::bind(&Gles::callGlIsPointInStrokePathNV, this, _1, _2));
        mFunctions.insert(256, std::bind(&Gles::callGlIsProgramPipelineEXT, this, _1, _2));
        mFunctions.insert(257, std::bind(&Gles::callGlIsQueryEXT, this, _1, _2));
        mFunctions.insert(258, std::bind(&Gles::callGlIsSyncAPPLE, this, _1, _2));
        mFunctions.insert(259, std::bind(&Gles::callGlIsTextureHandleResidentNV, this, _1, _2));
        mFunctions.insert(260, std::bind(&Gles::callGlIsVertexArrayOES, this, _1, _2));
        mFunctions.insert(261, std::bind(&Gles::callGlLabelObjectEXT, this, _1, _2));
        mFunctions.insert(262, std::bind(&Gles::callGlMakeImageHandleNonResidentNV, this, _1, _2));
        mFunctions.insert(263, std::bind(&Gles::callGlMakeImageHandleResidentNV, this, _1, _2));
        mFunctions.insert(264, std::bind(&Gles::callGlMakeTextureHandleNonResidentNV, this, _1, _2));
        mFunctions.insert(265, std::bind(&Gles::callGlMakeTextureHandleResidentNV, this, _1, _2));
        mFunctions.insert(266, std::bind(&Gles::callGlMapBufferOES, this, _1, _2));
        mFunctions.insert(267, std::bind(&Gles::callGlMapBufferRangeEXT, this, _1, _2));
        mFunctions.insert(268, std::bind(&Gles::callGlMatrixLoad3x2fNV, this, _1, _2));
        mFunctions.insert(269, std::bind(&Gles::callGlMatrixLoad3x3fNV, this, _1, _2));
        mFunctions.insert(270, std::bind(&Gles::callGlMatrixLoadTranspose3x3fNV, this, _1, _2));
        mFunctions.insert(271, std::bind(&Gles::callGlMatrixMult3x2fNV, this, _1, _2));
        mFunctions.insert(272, std::bind(&Gles::callGlMatrixMult3x3fNV, this, _1, _2));
        mFunctions.insert(273, std::bind(&Gles::callGlMatrixMultTranspose3x3fNV, this, _1, _2));
        mFunctions.insert(274, std::bind(&Gles::callGlMultiDrawArraysEXT, this, _1, _2));
        mFunctions.insert(275, std::bind(&Gles::callGlMultiDrawArraysIndirectEXT, this, _1, _2));
        mFunctions.insert(276, std::bind(&Gles::callGlMultiDrawElementsBaseVertexEXT, this, _1, _2));
        mFunctions.insert(277, std::bind(&Gles::callGlMultiDrawElementsBaseVertexOES, this, _1, _2));
        mFunctions.insert(278, std::bind(&Gles::callGlMultiDrawElementsEXT, this, _1, _2));
        mFunctions.insert(279, std::bind(&Gles::callGlMultiDrawElementsIndirectEXT, this, _1, _2));
        mFunctions.insert(280, std::bind(&Gles::callGlNamedFramebufferSampleLocationsfvNV, this, _1, _2));
        mFunctions.insert(281, std::bind(&Gles::callGlPatchParameteriOES, this, _1, _2));
        mFunctions.insert(282, std::bind(&Gles::callGlPathCommandsNV, this, _1, _2));
        mFunctions.insert(283, std::bind(&Gles::callGlPathCoordsNV, this, _1, _2));
        mFunctions.insert(284, std::bind(&Gles::callGlPathCoverDepthFuncNV, this, _1, _2));
        mFunctions.insert(285, std::bind(&Gles::callGlPathDashArrayNV, this, _1, _2));
        mFunctions.insert(286, std::bind(&Gles::callGlPathGlyphIndexArrayNV, this, _1, _2));
        mFunctions.insert(287, std::bind(&Gles::callGlPathGlyphIndexRangeNV, this, _1, _2));
        mFunctions.insert(288, std::bind(&Gles::callGlPathGlyphRangeNV, this, _1, _2));
        mFunctions.insert(289, std::bind(&Gles::callGlPathGlyphsNV, this, _1, _2));
        mFunctions.insert(290, std::bind(&Gles::callGlPathMemoryGlyphIndexArrayNV, this, _1, _2));
        mFunctions.insert(291, std::bind(&Gles::callGlPathParameterfNV, this, _1, _2));
        mFunctions.insert(292, std::bind(&Gles::callGlPathParameterfvNV, this, _1, _2));
        mFunctions.insert(293, std::bind(&Gles::callGlPathParameteriNV, this, _1, _2));
        mFunctions.insert(294, std::bind(&Gles::callGlPathParameterivNV, this, _1, _2));
        mFunctions.insert(295, std::bind(&Gles::callGlPathStencilDepthOffsetNV, this, _1, _2));
        mFunctions.insert(296, std::bind(&Gles::callGlPathStencilFuncNV, this, _1, _2));
        mFunctions.insert(297, std::bind(&Gles::callGlPathStringNV, this, _1, _2));
        mFunctions.insert(298, std::bind(&Gles::callGlPathSubCommandsNV, this, _1, _2));
        mFunctions.insert(299, std::bind(&Gles::callGlPathSubCoordsNV, this, _1, _2));
        mFunctions.insert(300, std::bind(&Gles::callGlPointAlongPathNV, this, _1, _2));
        mFunctions.insert(301, std::bind(&Gles::callGlPolygonModeNV, this, _1, _2));
        mFunctions.insert(302, std::bind(&Gles::callGlPopGroupMarkerEXT, this, _1, _2));
        mFunctions.insert(303, std::bind(&Gles::callGlPrimitiveBoundingBoxOES, this, _1, _2));
        mFunctions.insert(304, std::bind(&Gles::callGlProgramBinaryOES, this, _1, _2));
        mFunctions.insert(305, std::bind(&Gles::callGlProgramParameteriEXT, this, _1, _2));
        mFunctions.insert(306, std::bind(&Gles::callGlProgramPathFragmentInputGenNV, this, _1, _2));
        mFunctions.insert(307, std::bind(&Gles::callGlProgramUniform1fEXT, this, _1, _2));
        mFunctions.insert(308, std::bind(&Gles::callGlProgramUniform1fvEXT, this, _1, _2));
        mFunctions.insert(309, std::bind(&Gles::callGlProgramUniform1iEXT, this, _1, _2));
        mFunctions.insert(310, std::bind(&Gles::callGlProgramUniform1ivEXT, this, _1, _2));
        mFunctions.insert(311, std::bind(&Gles::callGlProgramUniform1uiEXT, this, _1, _2));
        mFunctions.insert(312, std::bind(&Gles::callGlProgramUniform1uivEXT, this, _1, _2));
        mFunctions.insert(313, std::bind(&Gles::callGlProgramUniform2fEXT, this, _1, _2));
        mFunctions.insert(314, std::bind(&Gles::callGlProgramUniform2fvEXT, this, _1, _2));
        mFunctions.insert(315, std::bind(&Gles::callGlProgramUniform2iEXT, this, _1, _2));
        mFunctions.insert(316, std::bind(&Gles::callGlProgramUniform2ivEXT, this, _1, _2));
        mFunctions.insert(317, std::bind(&Gles::callGlProgramUniform2uiEXT, this, _1, _2));
        mFunctions.insert(318, std::bind(&Gles::callGlProgramUniform2uivEXT, this, _1, _2));
        mFunctions.insert(319, std::bind(&Gles::callGlProgramUniform3fEXT, this, _1, _2));
        mFunctions.insert(320, std::bind(&Gles::callGlProgramUniform3fvEXT, this, _1, _2));
        mFunctions.insert(321, std::bind(&Gles::callGlProgramUniform3iEXT, this, _1, _2));
        mFunctions.insert(322, std::bind(&Gles::callGlProgramUniform3ivEXT, this, _1, _2));
        mFunctions.insert(323, std::bind(&Gles::callGlProgramUniform3uiEXT, this, _1, _2));
        mFunctions.insert(324, std::bind(&Gles::callGlProgramUniform3uivEXT, this, _1, _2));
        mFunctions.insert(325, std::bind(&Gles::callGlProgramUniform4fEXT, this, _1, _2));
        mFunctions.insert(326, std::bind(&Gles::callGlProgramUniform4fvEXT, this, _1, _2));
        mFunctions.insert(327, std::bind(&Gles::callGlProgramUniform4iEXT, this, _1, _2));
        mFunctions.insert(328, std::bind(&Gles::callGlProgramUniform4ivEXT, this, _1, _2));
        mFunctions.insert(329, std::bind(&Gles::callGlProgramUniform4uiEXT, this, _1, _2));
        mFunctions.insert(330, std::bind(&Gles::callGlProgramUniform4uivEXT, this, _1, _2));
        mFunctions.insert(331, std::bind(&Gles::callGlProgramUniformHandleui64NV, this, _1, _2));
        mFunctions.insert(332, std::bind(&Gles::callGlProgramUniformHandleui64vNV, this, _1, _2));
        mFunctions.insert(333, std::bind(&Gles::callGlProgramUniformMatrix2fvEXT, this, _1, _2));
        mFunctions.insert(334, std::bind(&Gles::callGlProgramUniformMatrix2x3fvEXT, this, _1, _2));
        mFunctions.insert(335, std::bind(&Gles::callGlProgramUniformMatrix2x4fvEXT, this, _1, _2));
        mFunctions.insert(336, std::bind(&Gles::callGlProgramUniformMatrix3fvEXT, this, _1, _2));
        mFunctions.insert(337, std::bind(&Gles::callGlProgramUniformMatrix3x2fvEXT, this, _1, _2));
        mFunctions.insert(338, std::bind(&Gles::callGlProgramUniformMatrix3x4fvEXT, this, _1, _2));
        mFunctions.insert(339, std::bind(&Gles::callGlProgramUniformMatrix4fvEXT, this, _1, _2));
        mFunctions.insert(340, std::bind(&Gles::callGlProgramUniformMatrix4x2fvEXT, this, _1, _2));
        mFunctions.insert(341, std::bind(&Gles::callGlProgramUniformMatrix4x3fvEXT, this, _1, _2));
        mFunctions.insert(342, std::bind(&Gles::callGlPushGroupMarkerEXT, this, _1, _2));
        mFunctions.insert(343, std::bind(&Gles::callGlQueryCounterEXT, this, _1, _2));
        mFunctions.insert(344, std::bind(&Gles::callGlRasterSamplesEXT, this, _1, _2));
        mFunctions.insert(345, std::bind(&Gles::callGlReadBufferIndexedEXT, this, _1, _2));
        mFunctions.insert(346, std::bind(&Gles::callGlReadBufferNV, this, _1, _2));
        mFunctions.insert(347, std::bind(&Gles::callGlReadnPixelsEXT, this, _1, _2));
        mFunctions.insert(348, std::bind(&Gles::callGlReadnPixelsKHR, this, _1, _2));
        mFunctions.insert(349, std::bind(&Gles::callGlRenderbufferStorageMultisampleANGLE, this, _1, _2));
        mFunctions.insert(350, std::bind(&Gles::callGlRenderbufferStorageMultisampleAPPLE, this, _1, _2));
        mFunctions.insert(351, std::bind(&Gles::callGlRenderbufferStorageMultisampleEXT, this, _1, _2));
        mFunctions.insert(352, std::bind(&Gles::callGlRenderbufferStorageMultisampleIMG, this, _1, _2));
        mFunctions.insert(353, std::bind(&Gles::callGlRenderbufferStorageMultisampleNV, this, _1, _2));
        mFunctions.insert(354, std::bind(&Gles::callGlResolveDepthValuesNV, this, _1, _2));
        mFunctions.insert(355, std::bind(&Gles::callGlResolveMultisampleFramebufferAPPLE, this, _1, _2));
        mFunctions.insert(356, std::bind(&Gles::callGlSamplerParameterIivOES, this, _1, _2));
        mFunctions.insert(357, std::bind(&Gles::callGlSamplerParameterIuivOES, this, _1, _2));
        mFunctions.insert(358, std::bind(&Gles::callGlScissorArrayvNV, this, _1, _2));
        mFunctions.insert(359, std::bind(&Gles::callGlScissorIndexedNV, this, _1, _2));
        mFunctions.insert(360, std::bind(&Gles::callGlScissorIndexedvNV, this, _1, _2));
        mFunctions.insert(361, std::bind(&Gles::callGlSelectPerfMonitorCountersAMD, this, _1, _2));
        mFunctions.insert(362, std::bind(&Gles::callGlSetFenceNV, this, _1, _2));
        mFunctions.insert(363, std::bind(&Gles::callGlStartTilingQCOM, this, _1, _2));
        mFunctions.insert(364, std::bind(&Gles::callGlStencilFillPathInstancedNV, this, _1, _2));
        mFunctions.insert(365, std::bind(&Gles::callGlStencilFillPathNV, this, _1, _2));
        mFunctions.insert(366, std::bind(&Gles::callGlStencilStrokePathInstancedNV, this, _1, _2));
        mFunctions.insert(367, std::bind(&Gles::callGlStencilStrokePathNV, this, _1, _2));
        mFunctions.insert(368, std::bind(&Gles::callGlStencilThenCoverFillPathInstancedNV, this, _1, _2));
        mFunctions.insert(369, std::bind(&Gles::callGlStencilThenCoverFillPathNV, this, _1, _2));
        mFunctions.insert(370, std::bind(&Gles::callGlStencilThenCoverStrokePathInstancedNV, this, _1, _2));
        mFunctions.insert(371, std::bind(&Gles::callGlStencilThenCoverStrokePathNV, this, _1, _2));
        mFunctions.insert(372, std::bind(&Gles::callGlSubpixelPrecisionBiasNV, this, _1, _2));
        mFunctions.insert(373, std::bind(&Gles::callGlTestFenceNV, this, _1, _2));
        mFunctions.insert(374, std::bind(&Gles::callGlTexBufferOES, this, _1, _2));
        mFunctions.insert(375, std::bind(&Gles::callGlTexBufferRangeOES, this, _1, _2));
        mFunctions.insert(376, std::bind(&Gles::callGlTexImage3DOES, this, _1, _2));
        mFunctions.insert(377, std::bind(&Gles::callGlTexPageCommitmentEXT, this, _1, _2));
        mFunctions.insert(378, std::bind(&Gles::callGlTexParameterIivOES, this, _1, _2));
        mFunctions.insert(379, std::bind(&Gles::callGlTexParameterIuivOES, this, _1, _2));
        mFunctions.insert(380, std::bind(&Gles::callGlTexStorage1DEXT, this, _1, _2));
        mFunctions.insert(381, std::bind(&Gles::callGlTexStorage2DEXT, this, _1, _2));
        mFunctions.insert(382, std::bind(&Gles::callGlTexStorage3DEXT, this, _1, _2));
        mFunctions.insert(383, std::bind(&Gles::callGlTexSubImage3DOES, this, _1, _2));
        mFunctions.insert(384, std::bind(&Gles::callGlTextureStorage1DEXT, this, _1, _2));
        mFunctions.insert(385, std::bind(&Gles::callGlTextureStorage2DEXT, this, _1, _2));
        mFunctions.insert(386, std::bind(&Gles::callGlTextureStorage3DEXT, this, _1, _2));
        mFunctions.insert(387, std::bind(&Gles::callGlTextureViewEXT, this, _1, _2));
        mFunctions.insert(388, std::bind(&Gles::callGlTextureViewOES, this, _1, _2));
        mFunctions.insert(389, std::bind(&Gles::callGlTransformPathNV, this, _1, _2));
        mFunctions.insert(390, std::bind(&Gles::callGlUniformHandleui64NV, this, _1, _2));
        mFunctions.insert(391, std::bind(&Gles::callGlUniformHandleui64vNV, this, _1, _2));
        mFunctions.insert(392, std::bind(&Gles::callGlUniformMatrix2x3fvNV, this, _1, _2));
        mFunctions.insert(393, std::bind(&Gles::callGlUniformMatrix2x4fvNV, this, _1, _2));
        mFunctions.insert(394, std::bind(&Gles::callGlUniformMatrix3x2fvNV, this, _1, _2));
        mFunctions.insert(395, std::bind(&Gles::callGlUniformMatrix3x4fvNV, this, _1, _2));
        mFunctions.insert(396, std::bind(&Gles::callGlUniformMatrix4x2fvNV, this, _1, _2));
        mFunctions.insert(397, std::bind(&Gles::callGlUniformMatrix4x3fvNV, this, _1, _2));
        mFunctions.insert(398, std::bind(&Gles::callGlUnmapBufferOES, this, _1, _2));
        mFunctions.insert(399, std::bind(&Gles::callGlUseProgramStagesEXT, this, _1, _2));
        mFunctions.insert(400, std::bind(&Gles::callGlValidateProgramPipelineEXT, this, _1, _2));
        mFunctions.insert(401, std::bind(&Gles::callGlVertexAttribDivisorANGLE, this, _1, _2));
        mFunctions.insert(402, std::bind(&Gles::callGlVertexAttribDivisorEXT, this, _1, _2));
        mFunctions.insert(403, std::bind(&Gles::callGlVertexAttribDivisorNV, this, _1, _2));
        mFunctions.insert(404, std::bind(&Gles::callGlViewportArrayvNV, this, _1, _2));
        mFunctions.insert(405, std::bind(&Gles::callGlViewportIndexedfNV, this, _1, _2));
        mFunctions.insert(406, std::bind(&Gles::callGlViewportIndexedfvNV, this, _1, _2));
        mFunctions.insert(407, std::bind(&Gles::callGlWaitSyncAPPLE, this, _1, _2));
        mFunctions.insert(408, std::bind(&Gles::callGlWeightPathsNV, this, _1, _2));
        mFunctions.insert(409, std::bind(&Gles::callGlBlendBarrier, this, _1, _2));
        mFunctions.insert(410, std::bind(&Gles::callGlBlendColor, this, _1, _2));
        mFunctions.insert(411, std::bind(&Gles::callGlBlendEquation, this, _1, _2));
        mFunctions.insert(412, std::bind(&Gles::callGlBlendEquationSeparate, this, _1, _2));
        mFunctions.insert(413, std::bind(&Gles::callGlBlendEquationSeparatei, this, _1, _2));
        mFunctions.insert(414, std::bind(&Gles::callGlBlendEquationi, this, _1, _2));
        mFunctions.insert(415, std::bind(&Gles::callGlBlendFunc, this, _1, _2));
        mFunctions.insert(416, std::bind(&Gles::callGlBlendFuncSeparate, this, _1, _2));
        mFunctions.insert(417, std::bind(&Gles::callGlBlendFuncSeparatei, this, _1, _2));
        mFunctions.insert(418, std::bind(&Gles::callGlBlendFunci, this, _1, _2));
        mFunctions.insert(419, std::bind(&Gles::callGlDepthFunc, this, _1, _2));
        mFunctions.insert(420, std::bind(&Gles::callGlSampleCoverage, this, _1, _2));
        mFunctions.insert(421, std::bind(&Gles::callGlSampleMaski, this, _1, _2));
        mFunctions.insert(422, std::bind(&Gles::callGlScissor, this, _1, _2));
        mFunctions.insert(423, std::bind(&Gles::callGlStencilFunc, this, _1, _2));
        mFunctions.insert(424, std::bind(&Gles::callGlStencilFuncSeparate, this, _1, _2));
        mFunctions.insert(425, std::bind(&Gles::callGlStencilOp, this, _1, _2));
        mFunctions.insert(426, std::bind(&Gles::callGlStencilOpSeparate, this, _1, _2));
        mFunctions.insert(427, std::bind(&Gles::callGlBindFramebuffer, this, _1, _2));
        mFunctions.insert(428, std::bind(&Gles::callGlBindRenderbuffer, this, _1, _2));
        mFunctions.insert(429, std::bind(&Gles::callGlBlitFramebuffer, this, _1, _2));
        mFunctions.insert(430, std::bind(&Gles::callGlCheckFramebufferStatus, this, _1, _2));
        mFunctions.insert(431, std::bind(&Gles::callGlClear, this, _1, _2));
        mFunctions.insert(432, std::bind(&Gles::callGlClearBufferfi, this, _1, _2));
        mFunctions.insert(433, std::bind(&Gles::callGlClearBufferfv, this, _1, _2));
        mFunctions.insert(434, std::bind(&Gles::callGlClearBufferiv, this, _1, _2));
        mFunctions.insert(435, std::bind(&Gles::callGlClearBufferuiv, this, _1, _2));
        mFunctions.insert(436, std::bind(&Gles::callGlClearColor, this, _1, _2));
        mFunctions.insert(437, std::bind(&Gles::callGlClearDepthf, this, _1, _2));
        mFunctions.insert(438, std::bind(&Gles::callGlClearStencil, this, _1, _2));
        mFunctions.insert(439, std::bind(&Gles::callGlColorMask, this, _1, _2));
        mFunctions.insert(440, std::bind(&Gles::callGlColorMaski, this, _1, _2));
        mFunctions.insert(441, std::bind(&Gles::callGlDeleteFramebuffers, this, _1, _2));
        mFunctions.insert(442, std::bind(&Gles::callGlDeleteRenderbuffers, this, _1, _2));
        mFunctions.insert(443, std::bind(&Gles::callGlDepthMask, this, _1, _2));
        mFunctions.insert(444, std::bind(&Gles::callGlDrawBuffers, this, _1, _2));
        mFunctions.insert(445, std::bind(&Gles::callGlFramebufferParameteri, this, _1, _2));
        mFunctions.insert(446, std::bind(&Gles::callGlFramebufferRenderbuffer, this, _1, _2));
        mFunctions.insert(447, std::bind(&Gles::callGlFramebufferTexture, this, _1, _2));
        mFunctions.insert(448, std::bind(&Gles::callGlFramebufferTexture2D, this, _1, _2));
        mFunctions.insert(449, std::bind(&Gles::callGlFramebufferTextureLayer, this, _1, _2));
        mFunctions.insert(450, std::bind(&Gles::callGlGenFramebuffers, this, _1, _2));
        mFunctions.insert(451, std::bind(&Gles::callGlGenRenderbuffers, this, _1, _2));
        mFunctions.insert(452, std::bind(&Gles::callGlGetFramebufferAttachmentParameteriv, this, _1, _2));
        mFunctions.insert(453, std::bind(&Gles::callGlGetFramebufferParameteriv, this, _1, _2));
        mFunctions.insert(454, std::bind(&Gles::callGlGetRenderbufferParameteriv, this, _1, _2));
        mFunctions.insert(455, std::bind(&Gles::callGlInvalidateFramebuffer, this, _1, _2));
        mFunctions.insert(456, std::bind(&Gles::callGlInvalidateSubFramebuffer, this, _1, _2));
        mFunctions.insert(457, std::bind(&Gles::callGlIsFramebuffer, this, _1, _2));
        mFunctions.insert(458, std::bind(&Gles::callGlIsRenderbuffer, this, _1, _2));
        mFunctions.insert(459, std::bind(&Gles::callGlReadBuffer, this, _1, _2));
        mFunctions.insert(460, std::bind(&Gles::callGlReadPixels, this, _1, _2));
        mFunctions.insert(461, std::bind(&Gles::callGlReadnPixels, this, _1, _2));
        mFunctions.insert(462, std::bind(&Gles::callGlRenderbufferStorage, this, _1, _2));
        mFunctions.insert(463, std::bind(&Gles::callGlRenderbufferStorageMultisample, this, _1, _2));
        mFunctions.insert(464, std::bind(&Gles::callGlStencilMask, this, _1, _2));
        mFunctions.insert(465, std::bind(&Gles::callGlStencilMaskSeparate, this, _1, _2));
        mFunctions.insert(466, std::bind(&Gles::callGlDisable, this, _1, _2));
        mFunctions.insert(467, std::bind(&Gles::callGlDisablei, this, _1, _2));
        mFunctions.insert(468, std::bind(&Gles::callGlEnable, this, _1, _2));
        mFunctions.insert(469, std::bind(&Gles::callGlEnablei, this, _1, _2));
        mFunctions.insert(470, std::bind(&Gles::callGlFinish, this, _1, _2));
        mFunctions.insert(471, std::bind(&Gles::callGlFlush, this, _1, _2));
        mFunctions.insert(472, std::bind(&Gles::callGlFlushMappedBufferRange, this, _1, _2));
        mFunctions.insert(473, std::bind(&Gles::callGlGetError, this, _1, _2));
        mFunctions.insert(474, std::bind(&Gles::callGlGetGraphicsResetStatus, this, _1, _2));
        mFunctions.insert(475, std::bind(&Gles::callGlHint, this, _1, _2));
        mFunctions.insert(476, std::bind(&Gles::callGlActiveShaderProgram, this, _1, _2));
        mFunctions.insert(477, std::bind(&Gles::callGlAttachShader, this, _1, _2));
        mFunctions.insert(478, std::bind(&Gles::callGlBindAttribLocation, this, _1, _2));
        mFunctions.insert(479, std::bind(&Gles::callGlBindProgramPipeline, this, _1, _2));
        mFunctions.insert(480, std::bind(&Gles::callGlCompileShader, this, _1, _2));
        mFunctions.insert(481, std::bind(&Gles::callGlCreateProgram, this, _1, _2));
        mFunctions.insert(482, std::bind(&Gles::callGlCreateShader, this, _1, _2));
        mFunctions.insert(483, std::bind(&Gles::callGlCreateShaderProgramv, this, _1, _2));
        mFunctions.insert(484, std::bind(&Gles::callGlDeleteProgram, this, _1, _2));
        mFunctions.insert(485, std::bind(&Gles::callGlDeleteProgramPipelines, this, _1, _2));
        mFunctions.insert(486, std::bind(&Gles::callGlDeleteShader, this, _1, _2));
        mFunctions.insert(487, std::bind(&Gles::callGlDetachShader, this, _1, _2));
        mFunctions.insert(488, std::bind(&Gles::callGlDispatchCompute, this, _1, _2));
        mFunctions.insert(489, std::bind(&Gles::callGlDispatchComputeIndirect, this, _1, _2));
        mFunctions.insert(490, std::bind(&Gles::callGlGenProgramPipelines, this, _1, _2));
        mFunctions.insert(491, std::bind(&Gles::callGlGetActiveAttrib, this, _1, _2));
        mFunctions.insert(492, std::bind(&Gles::callGlGetActiveUniform, this, _1, _2));
        mFunctions.insert(493, std::bind(&Gles::callGlGetActiveUniformBlockName, this, _1, _2));
        mFunctions.insert(494, std::bind(&Gles::callGlGetActiveUniformBlockiv, this, _1, _2));
        mFunctions.insert(495, std::bind(&Gles::callGlGetActiveUniformsiv, this, _1, _2));
        mFunctions.insert(496, std::bind(&Gles::callGlGetAttachedShaders, this, _1, _2));
        mFunctions.insert(497, std::bind(&Gles::callGlGetAttribLocation, this, _1, _2));
        mFunctions.insert(498, std::bind(&Gles::callGlGetFragDataLocation, this, _1, _2));
        mFunctions.insert(499, std::bind(&Gles::callGlGetProgramBinary, this, _1, _2));
        mFunctions.insert(500, std::bind(&Gles::callGlGetProgramInfoLog, this, _1, _2));
        mFunctions.insert(501, std::bind(&Gles::callGlGetProgramInterfaceiv, this, _1, _2));
        mFunctions.insert(502, std::bind(&Gles::callGlGetProgramPipelineInfoLog, this, _1, _2));
        mFunctions.insert(503, std::bind(&Gles::callGlGetProgramPipelineiv, this, _1, _2));
        mFunctions.insert(504, std::bind(&Gles::callGlGetProgramResourceIndex, this, _1, _2));
        mFunctions.insert(505, std::bind(&Gles::callGlGetProgramResourceLocation, this, _1, _2));
        mFunctions.insert(506, std::bind(&Gles::callGlGetProgramResourceName, this, _1, _2));
        mFunctions.insert(507, std::bind(&Gles::callGlGetProgramResourceiv, this, _1, _2));
        mFunctions.insert(508, std::bind(&Gles::callGlGetProgramiv, this, _1, _2));
        mFunctions.insert(509, std::bind(&Gles::callGlGetShaderInfoLog, this, _1, _2));
        mFunctions.insert(510, std::bind(&Gles::callGlGetShaderPrecisionFormat, this, _1, _2));
        mFunctions.insert(511, std::bind(&Gles::callGlGetShaderSource, this, _1, _2));
        mFunctions.insert(512, std::bind(&Gles::callGlGetShaderiv, this, _1, _2));
        mFunctions.insert(513, std::bind(&Gles::callGlGetUniformBlockIndex, this, _1, _2));
        mFunctions.insert(514, std::bind(&Gles::callGlGetUniformIndices, this, _1, _2));
        mFunctions.insert(515, std::bind(&Gles::callGlGetUniformLocation, this, _1, _2));
        mFunctions.insert(516, std::bind(&Gles::callGlGetUniformfv, this, _1, _2));
        mFunctions.insert(517, std::bind(&Gles::callGlGetUniformiv, this, _1, _2));
        mFunctions.insert(518, std::bind(&Gles::callGlGetUniformuiv, this, _1, _2));
        mFunctions.insert(519, std::bind(&Gles::callGlGetnUniformfv, this, _1, _2));
        mFunctions.insert(520, std::bind(&Gles::callGlGetnUniformiv, this, _1, _2));
        mFunctions.insert(521, std::bind(&Gles::callGlGetnUniformuiv, this, _1, _2));
        mFunctions.insert(522, std::bind(&Gles::callGlIsProgram, this, _1, _2));
        mFunctions.insert(523, std::bind(&Gles::callGlIsProgramPipeline, this, _1, _2));
        mFunctions.insert(524, std::bind(&Gles::callGlIsShader, this, _1, _2));
        mFunctions.insert(525, std::bind(&Gles::callGlLinkProgram, this, _1, _2));
        mFunctions.insert(526, std::bind(&Gles::callGlMemoryBarrier, this, _1, _2));
        mFunctions.insert(527, std::bind(&Gles::callGlMemoryBarrierByRegion, this, _1, _2));
        mFunctions.insert(528, std::bind(&Gles::callGlProgramBinary, this, _1, _2));
        mFunctions.insert(529, std::bind(&Gles::callGlProgramParameteri, this, _1, _2));
        mFunctions.insert(530, std::bind(&Gles::callGlProgramUniform1f, this, _1, _2));
        mFunctions.insert(531, std::bind(&Gles::callGlProgramUniform1fv, this, _1, _2));
        mFunctions.insert(532, std::bind(&Gles::callGlProgramUniform1i, this, _1, _2));
        mFunctions.insert(533, std::bind(&Gles::callGlProgramUniform1iv, this, _1, _2));
        mFunctions.insert(534, std::bind(&Gles::callGlProgramUniform1ui, this, _1, _2));
        mFunctions.insert(535, std::bind(&Gles::callGlProgramUniform1uiv, this, _1, _2));
        mFunctions.insert(536, std::bind(&Gles::callGlProgramUniform2f, this, _1, _2));
        mFunctions.insert(537, std::bind(&Gles::callGlProgramUniform2fv, this, _1, _2));
        mFunctions.insert(538, std::bind(&Gles::callGlProgramUniform2i, this, _1, _2));
        mFunctions.insert(539, std::bind(&Gles::callGlProgramUniform2iv, this, _1, _2));
        mFunctions.insert(540, std::bind(&Gles::callGlProgramUniform2ui, this, _1, _2));
        mFunctions.insert(541, std::bind(&Gles::callGlProgramUniform2uiv, this, _1, _2));
        mFunctions.insert(542, std::bind(&Gles::callGlProgramUniform3f, this, _1, _2));
        mFunctions.insert(543, std::bind(&Gles::callGlProgramUniform3fv, this, _1, _2));
        mFunctions.insert(544, std::bind(&Gles::callGlProgramUniform3i, this, _1, _2));
        mFunctions.insert(545, std::bind(&Gles::callGlProgramUniform3iv, this, _1, _2));
        mFunctions.insert(546, std::bind(&Gles::callGlProgramUniform3ui, this, _1, _2));
        mFunctions.insert(547, std::bind(&Gles::callGlProgramUniform3uiv, this, _1, _2));
        mFunctions.insert(548, std::bind(&Gles::callGlProgramUniform4f, this, _1, _2));
        mFunctions.insert(549, std::bind(&Gles::callGlProgramUniform4fv, this, _1, _2));
        mFunctions.insert(550, std::bind(&Gles::callGlProgramUniform4i, this, _1, _2));
        mFunctions.insert(551, std::bind(&Gles::callGlProgramUniform4iv, this, _1, _2));
        mFunctions.insert(552, std::bind(&Gles::callGlProgramUniform4ui, this, _1, _2));
        mFunctions.insert(553, std::bind(&Gles::callGlProgramUniform4uiv, this, _1, _2));
        mFunctions.insert(554, std::bind(&Gles::callGlProgramUniformMatrix2fv, this, _1, _2));
        mFunctions.insert(555, std::bind(&Gles::callGlProgramUniformMatrix2x3fv, this, _1, _2));
        mFunctions.insert(556, std::bind(&Gles::callGlProgramUniformMatrix2x4fv, this, _1, _2));
        mFunctions.insert(557, std::bind(&Gles::callGlProgramUniformMatrix3fv, this, _1, _2));
        mFunctions.insert(558, std::bind(&Gles::callGlProgramUniformMatrix3x2fv, this, _1, _2));
        mFunctions.insert(559, std::bind(&Gles::callGlProgramUniformMatrix3x4fv, this, _1, _2));
        mFunctions.insert(560, std::bind(&Gles::callGlProgramUniformMatrix4fv, this, _1, _2));
        mFunctions.insert(561, std::bind(&Gles::callGlProgramUniformMatrix4x2fv, this, _1, _2));
        mFunctions.insert(562, std::bind(&Gles::callGlProgramUniformMatrix4x3fv, this, _1, _2));
        mFunctions.insert(563, std::bind(&Gles::callGlReleaseShaderCompiler, this, _1, _2));
        mFunctions.insert(564, std::bind(&Gles::callGlShaderBinary, this, _1, _2));
        mFunctions.insert(565, std::bind(&Gles::callGlShaderSource, this, _1, _2));
        mFunctions.insert(566, std::bind(&Gles::callGlUniform1f, this, _1, _2));
        mFunctions.insert(567, std::bind(&Gles::callGlUniform1fv, this, _1, _2));
        mFunctions.insert(568, std::bind(&Gles::callGlUniform1i, this, _1, _2));
        mFunctions.insert(569, std::bind(&Gles::callGlUniform1iv, this, _1, _2));
        mFunctions.insert(570, std::bind(&Gles::callGlUniform1ui, this, _1, _2));
        mFunctions.insert(571, std::bind(&Gles::callGlUniform1uiv, this, _1, _2));
        mFunctions.insert(572, std::bind(&Gles::callGlUniform2f, this, _1, _2));
        mFunctions.insert(573, std::bind(&Gles::callGlUniform2fv, this, _1, _2));
        mFunctions.insert(574, std::bind(&Gles::callGlUniform2i, this, _1, _2));
        mFunctions.insert(575, std::bind(&Gles::callGlUniform2iv, this, _1, _2));
        mFunctions.insert(576, std::bind(&Gles::callGlUniform2ui, this, _1, _2));
        mFunctions.insert(577, std::bind(&Gles::callGlUniform2uiv, this, _1, _2));
        mFunctions.insert(578, std::bind(&Gles::callGlUniform3f, this, _1, _2));
        mFunctions.insert(579, std::bind(&Gles::callGlUniform3fv, this, _1, _2));
        mFunctions.insert(580, std::bind(&Gles::callGlUniform3i, this, _1, _2));
        mFunctions.insert(581, std::bind(&Gles::callGlUniform3iv, this, _1, _2));
        mFunctions.insert(582, std::bind(&Gles::callGlUniform3ui, this, _1, _2));
        mFunctions.insert(583, std::bind(&Gles::callGlUniform3uiv, this, _1, _2));
        mFunctions.insert(584, std::bind(&Gles::callGlUniform4f, this, _1, _2));
        mFunctions.insert(585, std::bind(&Gles::callGlUniform4fv, this, _1, _2));
        mFunctions.insert(586, std::bind(&Gles::callGlUniform4i, this, _1, _2));
        mFunctions.insert(587, std::bind(&Gles::callGlUniform4iv, this, _1, _2));
        mFunctions.insert(588, std::bind(&Gles::callGlUniform4ui, this, _1, _2));
        mFunctions.insert(589, std::bind(&Gles::callGlUniform4uiv, this, _1, _2));
        mFunctions.insert(590, std::bind(&Gles::callGlUniformBlockBinding, this, _1, _2));
        mFunctions.insert(591, std::bind(&Gles::callGlUniformMatrix2fv, this, _1, _2));
        mFunctions.insert(592, std::bind(&Gles::callGlUniformMatrix2x3fv, this, _1, _2));
        mFunctions.insert(593, std::bind(&Gles::callGlUniformMatrix2x4fv, this, _1, _2));
        mFunctions.insert(594, std::bind(&Gles::callGlUniformMatrix3fv, this, _1, _2));
        mFunctions.insert(595, std::bind(&Gles::callGlUniformMatrix3x2fv, this, _1, _2));
        mFunctions.insert(596, std::bind(&Gles::callGlUniformMatrix3x4fv, this, _1, _2));
        mFunctions.insert(597, std::bind(&Gles::callGlUniformMatrix4fv, this, _1, _2));
        mFunctions.insert(598, std::bind(&Gles::callGlUniformMatrix4x2fv, this, _1, _2));
        mFunctions.insert(599, std::bind(&Gles::callGlUniformMatrix4x3fv, this, _1, _2));
        mFunctions.insert(600, std::bind(&Gles::callGlUseProgram, this, _1, _2));
        mFunctions.insert(601, std::bind(&Gles::callGlUseProgramStages, this, _1, _2));
        mFunctions.insert(602, std::bind(&Gles::callGlValidateProgram, this, _1, _2));
        mFunctions.insert(603, std::bind(&Gles::callGlValidateProgramPipeline, this, _1, _2));
        mFunctions.insert(604, std::bind(&Gles::callGlCullFace, this, _1, _2));
        mFunctions.insert(605, std::bind(&Gles::callGlDepthRangef, this, _1, _2));
        mFunctions.insert(606, std::bind(&Gles::callGlFrontFace, this, _1, _2));
        mFunctions.insert(607, std::bind(&Gles::callGlGetMultisamplefv, this, _1, _2));
        mFunctions.insert(608, std::bind(&Gles::callGlLineWidth, this, _1, _2));
        mFunctions.insert(609, std::bind(&Gles::callGlMinSampleShading, this, _1, _2));
        mFunctions.insert(610, std::bind(&Gles::callGlPolygonOffset, this, _1, _2));
        mFunctions.insert(611, std::bind(&Gles::callGlViewport, this, _1, _2));
        mFunctions.insert(612, std::bind(&Gles::callGlGetBooleaniV, this, _1, _2));
        mFunctions.insert(613, std::bind(&Gles::callGlGetBooleanv, this, _1, _2));
        mFunctions.insert(614, std::bind(&Gles::callGlGetFloatv, this, _1, _2));
        mFunctions.insert(615, std::bind(&Gles::callGlGetInteger64iV, this, _1, _2));
        mFunctions.insert(616, std::bind(&Gles::callGlGetInteger64v, this, _1, _2));
        mFunctions.insert(617, std::bind(&Gles::callGlGetIntegeriV, this, _1, _2));
        mFunctions.insert(618, std::bind(&Gles::callGlGetIntegerv, this, _1, _2));
        mFunctions.insert(619, std::bind(&Gles::callGlGetInternalformativ, this, _1, _2));
        mFunctions.insert(620, std::bind(&Gles::callGlGetString, this, _1, _2));
        mFunctions.insert(621, std::bind(&Gles::callGlGetStringi, this, _1, _2));
        mFunctions.insert(622, std::bind(&Gles::callGlIsEnabled, this, _1, _2));
        mFunctions.insert(623, std::bind(&Gles::callGlIsEnabledi, this, _1, _2));
        mFunctions.insert(624, std::bind(&Gles::callGlClientWaitSync, this, _1, _2));
        mFunctions.insert(625, std::bind(&Gles::callGlDeleteSync, this, _1, _2));
        mFunctions.insert(626, std::bind(&Gles::callGlFenceSync, this, _1, _2));
        mFunctions.insert(627, std::bind(&Gles::callGlGetSynciv, this, _1, _2));
        mFunctions.insert(628, std::bind(&Gles::callGlIsSync, this, _1, _2));
        mFunctions.insert(629, std::bind(&Gles::callGlWaitSync, this, _1, _2));
        mFunctions.insert(630, std::bind(&Gles::callGlActiveTexture, this, _1, _2));
        mFunctions.insert(631, std::bind(&Gles::callGlBindImageTexture, this, _1, _2));
        mFunctions.insert(632, std::bind(&Gles::callGlBindSampler, this, _1, _2));
        mFunctions.insert(633, std::bind(&Gles::callGlBindTexture, this, _1, _2));
        mFunctions.insert(634, std::bind(&Gles::callGlCompressedTexImage2D, this, _1, _2));
        mFunctions.insert(635, std::bind(&Gles::callGlCompressedTexImage3D, this, _1, _2));
        mFunctions.insert(636, std::bind(&Gles::callGlCompressedTexSubImage2D, this, _1, _2));
        mFunctions.insert(637, std::bind(&Gles::callGlCompressedTexSubImage3D, this, _1, _2));
        mFunctions.insert(638, std::bind(&Gles::callGlCopyImageSubData, this, _1, _2));
        mFunctions.insert(639, std::bind(&Gles::callGlCopyTexImage2D, this, _1, _2));
        mFunctions.insert(640, std::bind(&Gles::callGlCopyTexSubImage2D, this, _1, _2));
        mFunctions.insert(641, std::bind(&Gles::callGlCopyTexSubImage3D, this, _1, _2));
        mFunctions.insert(642, std::bind(&Gles::callGlDeleteSamplers, this, _1, _2));
        mFunctions.insert(643, std::bind(&Gles::callGlDeleteTextures, this, _1, _2));
        mFunctions.insert(644, std::bind(&Gles::callGlGenSamplers, this, _1, _2));
        mFunctions.insert(645, std::bind(&Gles::callGlGenTextures, this, _1, _2));
        mFunctions.insert(646, std::bind(&Gles::callGlGenerateMipmap, this, _1, _2));
        mFunctions.insert(647, std::bind(&Gles::callGlGetSamplerParameterIiv, this, _1, _2));
        mFunctions.insert(648, std::bind(&Gles::callGlGetSamplerParameterIuiv, this, _1, _2));
        mFunctions.insert(649, std::bind(&Gles::callGlGetSamplerParameterfv, this, _1, _2));
        mFunctions.insert(650, std::bind(&Gles::callGlGetSamplerParameteriv, this, _1, _2));
        mFunctions.insert(651, std::bind(&Gles::callGlGetTexLevelParameterfv, this, _1, _2));
        mFunctions.insert(652, std::bind(&Gles::callGlGetTexLevelParameteriv, this, _1, _2));
        mFunctions.insert(653, std::bind(&Gles::callGlGetTexParameterIiv, this, _1, _2));
        mFunctions.insert(654, std::bind(&Gles::callGlGetTexParameterIuiv, this, _1, _2));
        mFunctions.insert(655, std::bind(&Gles::callGlGetTexParameterfv, this, _1, _2));
        mFunctions.insert(656, std::bind(&Gles::callGlGetTexParameteriv, this, _1, _2));
        mFunctions.insert(657, std::bind(&Gles::callGlIsSampler, this, _1, _2));
        mFunctions.insert(658, std::bind(&Gles::callGlIsTexture, this, _1, _2));
        mFunctions.insert(659, std::bind(&Gles::callGlPixelStorei, this, _1, _2));
        mFunctions.insert(660, std::bind(&Gles::callGlSamplerParameterIiv, this, _1, _2));
        mFunctions.insert(661, std::bind(&Gles::callGlSamplerParameterIuiv, this, _1, _2));
        mFunctions.insert(662, std::bind(&Gles::callGlSamplerParameterf, this, _1, _2));
        mFunctions.insert(663, std::bind(&Gles::callGlSamplerParameterfv, this, _1, _2));
        mFunctions.insert(664, std::bind(&Gles::callGlSamplerParameteri, this, _1, _2));
        mFunctions.insert(665, std::bind(&Gles::callGlSamplerParameteriv, this, _1, _2));
        mFunctions.insert(666, std::bind(&Gles::callGlTexBuffer, this, _1, _2));
        mFunctions.insert(667, std::bind(&Gles::callGlTexBufferRange, this, _1, _2));
        mFunctions.insert(668, std::bind(&Gles::callGlTexImage2D, this, _1, _2));
        mFunctions.insert(669, std::bind(&Gles::callGlTexImage3D, this, _1, _2));
        mFunctions.insert(670, std::bind(&Gles::callGlTexParameterIiv, this, _1, _2));
        mFunctions.insert(671, std::bind(&Gles::callGlTexParameterIuiv, this, _1, _2));
        mFunctions.insert(672, std::bind(&Gles::callGlTexParameterf, this, _1, _2));
        mFunctions.insert(673, std::bind(&Gles::callGlTexParameterfv, this, _1, _2));
        mFunctions.insert(674, std::bind(&Gles::callGlTexParameteri, this, _1, _2));
        mFunctions.insert(675, std::bind(&Gles::callGlTexParameteriv, this, _1, _2));
        mFunctions.insert(676, std::bind(&Gles::callGlTexStorage2D, this, _1, _2));
        mFunctions.insert(677, std::bind(&Gles::callGlTexStorage2DMultisample, this, _1, _2));
        mFunctions.insert(678, std::bind(&Gles::callGlTexStorage3D, this, _1, _2));
        mFunctions.insert(679, std::bind(&Gles::callGlTexStorage3DMultisample, this, _1, _2));
        mFunctions.insert(680, std::bind(&Gles::callGlTexSubImage2D, this, _1, _2));
        mFunctions.insert(681, std::bind(&Gles::callGlTexSubImage3D, this, _1, _2));
        mFunctions.insert(682, std::bind(&Gles::callGlBeginTransformFeedback, this, _1, _2));
        mFunctions.insert(683, std::bind(&Gles::callGlBindTransformFeedback, this, _1, _2));
        mFunctions.insert(684, std::bind(&Gles::callGlDeleteTransformFeedbacks, this, _1, _2));
        mFunctions.insert(685, std::bind(&Gles::callGlEndTransformFeedback, this, _1, _2));
        mFunctions.insert(686, std::bind(&Gles::callGlGenTransformFeedbacks, this, _1, _2));
        mFunctions.insert(687, std::bind(&Gles::callGlGetTransformFeedbackVarying, this, _1, _2));
        mFunctions.insert(688, std::bind(&Gles::callGlIsTransformFeedback, this, _1, _2));
        mFunctions.insert(689, std::bind(&Gles::callGlPauseTransformFeedback, this, _1, _2));
        mFunctions.insert(690, std::bind(&Gles::callGlResumeTransformFeedback, this, _1, _2));
        mFunctions.insert(691, std::bind(&Gles::callGlTransformFeedbackVaryings, this, _1, _2));
        mFunctions.insert(692, std::bind(&Gles::callGlBindVertexArray, this, _1, _2));
        mFunctions.insert(693, std::bind(&Gles::callGlBindVertexBuffer, this, _1, _2));
        mFunctions.insert(694, std::bind(&Gles::callGlDeleteVertexArrays, this, _1, _2));
        mFunctions.insert(695, std::bind(&Gles::callGlDisableVertexAttribArray, this, _1, _2));
        mFunctions.insert(696, std::bind(&Gles::callGlEnableVertexAttribArray, this, _1, _2));
        mFunctions.insert(697, std::bind(&Gles::callGlGenVertexArrays, this, _1, _2));
        mFunctions.insert(698, std::bind(&Gles::callGlGetVertexAttribIiv, this, _1, _2));
        mFunctions.insert(699, std::bind(&Gles::callGlGetVertexAttribIuiv, this, _1, _2));
        mFunctions.insert(700, std::bind(&Gles::callGlGetVertexAttribPointerv, this, _1, _2));
        mFunctions.insert(701, std::bind(&Gles::callGlGetVertexAttribfv, this, _1, _2));
        mFunctions.insert(702, std::bind(&Gles::callGlGetVertexAttribiv, this, _1, _2));
        mFunctions.insert(703, std::bind(&Gles::callGlIsVertexArray, this, _1, _2));
        mFunctions.insert(704, std::bind(&Gles::callGlVertexAttrib1f, this, _1, _2));
        mFunctions.insert(705, std::bind(&Gles::callGlVertexAttrib1fv, this, _1, _2));
        mFunctions.insert(706, std::bind(&Gles::callGlVertexAttrib2f, this, _1, _2));
        mFunctions.insert(707, std::bind(&Gles::callGlVertexAttrib2fv, this, _1, _2));
        mFunctions.insert(708, std::bind(&Gles::callGlVertexAttrib3f, this, _1, _2));
        mFunctions.insert(709, std::bind(&Gles::callGlVertexAttrib3fv, this, _1, _2));
        mFunctions.insert(710, std::bind(&Gles::callGlVertexAttrib4f, this, _1, _2));
        mFunctions.insert(711, std::bind(&Gles::callGlVertexAttrib4fv, this, _1, _2));
        mFunctions.insert(712, std::bind(&Gles::callGlVertexAttribBinding, this, _1, _2));
        mFunctions.insert(713, std::bind(&Gles::callGlVertexAttribDivisor, this, _1, _2));
        mFunctions.insert(714, std::bind(&Gles::callGlVertexAttribFormat, this, _1, _2));
        mFunctions.insert(715, std::bind(&Gles::callGlVertexAttribI4i, this, _1, _2));
        mFunctions.insert(716, std::bind(&Gles::callGlVertexAttribI4iv, this, _1, _2));
        mFunctions.insert(717, std::bind(&Gles::callGlVertexAttribI4ui, this, _1, _2));
        mFunctions.insert(718, std::bind(&Gles::callGlVertexAttribI4uiv, this, _1, _2));
        mFunctions.insert(719, std::bind(&Gles::callGlVertexAttribIFormat, this, _1, _2));
        mFunctions.insert(720, std::bind(&Gles::callGlVertexAttribIPointer, this, _1, _2));
        mFunctions.insert(721, std::bind(&Gles::callGlVertexAttribPointer, this, _1, _2));
        mFunctions.insert(722, std::bind(&Gles::callGlVertexBindingDivisor, this, _1, _2));
        mFunctions.insert(723, std::bind(&Gles::callEglInitialize, this, _1, _2));
        mFunctions.insert(724, std::bind(&Gles::callEglCreateContext, this, _1, _2));
        mFunctions.insert(725, std::bind(&Gles::callEglMakeCurrent, this, _1, _2));
        mFunctions.insert(726, std::bind(&Gles::callEglSwapBuffers, this, _1, _2));
        mFunctions.insert(727, std::bind(&Gles::callEglSwapBuffersWithDamageKHR, this, _1, _2));
        mFunctions.insert(728, std::bind(&Gles::callEglQuerySurface, this, _1, _2));
        mFunctions.insert(729, std::bind(&Gles::callEglQueryContext, this, _1, _2));
        mFunctions.insert(730, std::bind(&Gles::callEglChooseConfig, this, _1, _2));
        mFunctions.insert(731, std::bind(&Gles::callEglGetConfigAttrib, this, _1, _2));
        mFunctions.insert(732, std::bind(&Gles::callGlXCreateContext, this, _1, _2));
        mFunctions.insert(733, std::bind(&Gles::callGlXCreateNewContext, this, _1, _2));
        mFunctions.insert(734, std::bind(&Gles::callGlXMakeContextCurrent, this, _1, _2));
        mFunctions.insert(735, std::bind(&Gles::callGlXMakeCurrent, this, _1, _2));
        mFunctions.insert(736, std::bind(&Gles::callGlXSwapBuffers, this, _1, _2));
        mFunctions.insert(737, std::bind(&Gles::callGlXQueryDrawable, this, _1, _2));
        mFunctions.insert(738, std::bind(&Gles::callWglCreateContext, this, _1, _2));
        mFunctions.insert(739, std::bind(&Gles::callWglCreateContextAttribsARB, this, _1, _2));
        mFunctions.insert(740, std::bind(&Gles::callWglMakeCurrent, this, _1, _2));
        mFunctions.insert(741, std::bind(&Gles::callWglSwapBuffers, this, _1, _2));
        mFunctions.insert(742, std::bind(&Gles::callCGLCreateContext, this, _1, _2));
        mFunctions.insert(743, std::bind(&Gles::callCGLSetCurrentContext, this, _1, _2));
        mFunctions.insert(744, std::bind(&Gles::callCGLGetSurface, this, _1, _2));
        mFunctions.insert(745, std::bind(&Gles::callCGSGetSurfaceBounds, this, _1, _2));
        mFunctions.insert(746, std::bind(&Gles::callCGLFlushDrawable, this, _1, _2));
        mFunctions.insert(747, std::bind(&Gles::callGlGetQueryObjecti64v, this, _1, _2));
        mFunctions.insert(748, std::bind(&Gles::callGlGetQueryObjectui64v, this, _1, _2));
        mFunctions.insert(749, std::bind(&Gles::callGlAlphaFunc, this, _1, _2));
        mFunctions.insert(750, std::bind(&Gles::callGlAlphaFuncx, this, _1, _2));
        mFunctions.insert(751, std::bind(&Gles::callGlAlphaFuncxOES, this, _1, _2));
        mFunctions.insert(752, std::bind(&Gles::callGlBindFramebufferOES, this, _1, _2));
        mFunctions.insert(753, std::bind(&Gles::callGlBindRenderbufferOES, this, _1, _2));
        mFunctions.insert(754, std::bind(&Gles::callGlBlendEquationOES, this, _1, _2));
        mFunctions.insert(755, std::bind(&Gles::callGlBlendEquationSeparateOES, this, _1, _2));
        mFunctions.insert(756, std::bind(&Gles::callGlBlendFuncSeparateOES, this, _1, _2));
        mFunctions.insert(757, std::bind(&Gles::callGlCheckFramebufferStatusOES, this, _1, _2));
        mFunctions.insert(758, std::bind(&Gles::callGlClearColorx, this, _1, _2));
        mFunctions.insert(759, std::bind(&Gles::callGlClearColorxOES, this, _1, _2));
        mFunctions.insert(760, std::bind(&Gles::callGlClearDepthfOES, this, _1, _2));
        mFunctions.insert(761, std::bind(&Gles::callGlClearDepthx, this, _1, _2));
        mFunctions.insert(762, std::bind(&Gles::callGlClearDepthxOES, this, _1, _2));
        mFunctions.insert(763, std::bind(&Gles::callGlClientActiveTexture, this, _1, _2));
        mFunctions.insert(764, std::bind(&Gles::callGlClipPlanef, this, _1, _2));
        mFunctions.insert(765, std::bind(&Gles::callGlClipPlanefIMG, this, _1, _2));
        mFunctions.insert(766, std::bind(&Gles::callGlClipPlanefOES, this, _1, _2));
        mFunctions.insert(767, std::bind(&Gles::callGlClipPlanex, this, _1, _2));
        mFunctions.insert(768, std::bind(&Gles::callGlClipPlanexIMG, this, _1, _2));
        mFunctions.insert(769, std::bind(&Gles::callGlClipPlanexOES, this, _1, _2));
        mFunctions.insert(770, std::bind(&Gles::callGlColor4f, this, _1, _2));
        mFunctions.insert(771, std::bind(&Gles::callGlColor4ub, this, _1, _2));
        mFunctions.insert(772, std::bind(&Gles::callGlColor4x, this, _1, _2));
        mFunctions.insert(773, std::bind(&Gles::callGlColor4xOES, this, _1, _2));
        mFunctions.insert(774, std::bind(&Gles::callGlColorPointer, this, _1, _2));
        mFunctions.insert(775, std::bind(&Gles::callGlCurrentPaletteMatrixOES, this, _1, _2));
        mFunctions.insert(776, std::bind(&Gles::callGlDeleteFramebuffersOES, this, _1, _2));
        mFunctions.insert(777, std::bind(&Gles::callGlDeleteRenderbuffersOES, this, _1, _2));
        mFunctions.insert(778, std::bind(&Gles::callGlDepthRangefOES, this, _1, _2));
        mFunctions.insert(779, std::bind(&Gles::callGlDepthRangex, this, _1, _2));
        mFunctions.insert(780, std::bind(&Gles::callGlDepthRangexOES, this, _1, _2));
        mFunctions.insert(781, std::bind(&Gles::callGlDisableClientState, this, _1, _2));
        mFunctions.insert(782, std::bind(&Gles::callGlDrawTexfOES, this, _1, _2));
        mFunctions.insert(783, std::bind(&Gles::callGlDrawTexfvOES, this, _1, _2));
        mFunctions.insert(784, std::bind(&Gles::callGlDrawTexiOES, this, _1, _2));
        mFunctions.insert(785, std::bind(&Gles::callGlDrawTexivOES, this, _1, _2));
        mFunctions.insert(786, std::bind(&Gles::callGlDrawTexsOES, this, _1, _2));
        mFunctions.insert(787, std::bind(&Gles::callGlDrawTexsvOES, this, _1, _2));
        mFunctions.insert(788, std::bind(&Gles::callGlDrawTexxOES, this, _1, _2));
        mFunctions.insert(789, std::bind(&Gles::callGlDrawTexxvOES, this, _1, _2));
        mFunctions.insert(790, std::bind(&Gles::callGlEnableClientState, this, _1, _2));
        mFunctions.insert(791, std::bind(&Gles::callGlFogf, this, _1, _2));
        mFunctions.insert(792, std::bind(&Gles::callGlFogfv, this, _1, _2));
        mFunctions.insert(793, std::bind(&Gles::callGlFogx, this, _1, _2));
        mFunctions.insert(794, std::bind(&Gles::callGlFogxOES, this, _1, _2));
        mFunctions.insert(795, std::bind(&Gles::callGlFogxv, this, _1, _2));
        mFunctions.insert(796, std::bind(&Gles::callGlFogxvOES, this, _1, _2));
        mFunctions.insert(797, std::bind(&Gles::callGlFramebufferRenderbufferOES, this, _1, _2));
        mFunctions.insert(798, std::bind(&Gles::callGlFramebufferTexture2DOES, this, _1, _2));
        mFunctions.insert(799, std::bind(&Gles::callGlFrustumf, this, _1, _2));
        mFunctions.insert(800, std::bind(&Gles::callGlFrustumfOES, this, _1, _2));
        mFunctions.insert(801, std::bind(&Gles::callGlFrustumx, this, _1, _2));
        mFunctions.insert(802, std::bind(&Gles::callGlFrustumxOES, this, _1, _2));
        mFunctions.insert(803, std::bind(&Gles::callGlGenFramebuffersOES, this, _1, _2));
        mFunctions.insert(804, std::bind(&Gles::callGlGenRenderbuffersOES, this, _1, _2));
        mFunctions.insert(805, std::bind(&Gles::callGlGenerateMipmapOES, this, _1, _2));
        mFunctions.insert(806, std::bind(&Gles::callGlGetClipPlanef, this, _1, _2));
        mFunctions.insert(807, std::bind(&Gles::callGlGetClipPlanefOES, this, _1, _2));
        mFunctions.insert(808, std::bind(&Gles::callGlGetClipPlanex, this, _1, _2));
        mFunctions.insert(809, std::bind(&Gles::callGlGetClipPlanexOES, this, _1, _2));
        mFunctions.insert(810, std::bind(&Gles::callGlGetFixedv, this, _1, _2));
        mFunctions.insert(811, std::bind(&Gles::callGlGetFixedvOES, this, _1, _2));
        mFunctions.insert(812, std::bind(&Gles::callGlGetFramebufferAttachmentParameterivOES, this, _1, _2));
        mFunctions.insert(813, std::bind(&Gles::callGlGetLightfv, this, _1, _2));
        mFunctions.insert(814, std::bind(&Gles::callGlGetLightxv, this, _1, _2));
        mFunctions.insert(815, std::bind(&Gles::callGlGetLightxvOES, this, _1, _2));
        mFunctions.insert(816, std::bind(&Gles::callGlGetMaterialfv, this, _1, _2));
        mFunctions.insert(817, std::bind(&Gles::callGlGetMaterialxv, this, _1, _2));
        mFunctions.insert(818, std::bind(&Gles::callGlGetMaterialxvOES, this, _1, _2));
        mFunctions.insert(819, std::bind(&Gles::callGlGetRenderbufferParameterivOES, this, _1, _2));
        mFunctions.insert(820, std::bind(&Gles::callGlGetTexEnvfv, this, _1, _2));
        mFunctions.insert(821, std::bind(&Gles::callGlGetTexEnviv, this, _1, _2));
        mFunctions.insert(822, std::bind(&Gles::callGlGetTexEnvxv, this, _1, _2));
        mFunctions.insert(823, std::bind(&Gles::callGlGetTexEnvxvOES, this, _1, _2));
        mFunctions.insert(824, std::bind(&Gles::callGlGetTexGenfvOES, this, _1, _2));
        mFunctions.insert(825, std::bind(&Gles::callGlGetTexGenivOES, this, _1, _2));
        mFunctions.insert(826, std::bind(&Gles::callGlGetTexGenxvOES, this, _1, _2));
        mFunctions.insert(827, std::bind(&Gles::callGlGetTexParameterxv, this, _1, _2));
        mFunctions.insert(828, std::bind(&Gles::callGlGetTexParameterxvOES, this, _1, _2));
        mFunctions.insert(829, std::bind(&Gles::callGlIsFramebufferOES, this, _1, _2));
        mFunctions.insert(830, std::bind(&Gles::callGlIsRenderbufferOES, this, _1, _2));
        mFunctions.insert(831, std::bind(&Gles::callGlLightModelf, this, _1, _2));
        mFunctions.insert(832, std::bind(&Gles::callGlLightModelfv, this, _1, _2));
        mFunctions.insert(833, std::bind(&Gles::callGlLightModelx, this, _1, _2));
        mFunctions.insert(834, std::bind(&Gles::callGlLightModelxOES, this, _1, _2));
        mFunctions.insert(835, std::bind(&Gles::callGlLightModelxv, this, _1, _2));
        mFunctions.insert(836, std::bind(&Gles::callGlLightModelxvOES, this, _1, _2));
        mFunctions.insert(837, std::bind(&Gles::callGlLightf, this, _1, _2));
        mFunctions.insert(838, std::bind(&Gles::callGlLightfv, this, _1, _2));
        mFunctions.insert(839, std::bind(&Gles::callGlLightx, this, _1, _2));
        mFunctions.insert(840, std::bind(&Gles::callGlLightxOES, this, _1, _2));
        mFunctions.insert(841, std::bind(&Gles::callGlLightxv, this, _1, _2));
        mFunctions.insert(842, std::bind(&Gles::callGlLightxvOES, this, _1, _2));
        mFunctions.insert(843, std::bind(&Gles::callGlLineWidthx, this, _1, _2));
        mFunctions.insert(844, std::bind(&Gles::callGlLineWidthxOES, this, _1, _2));
        mFunctions.insert(845, std::bind(&Gles::callGlLoadIdentity, this, _1, _2));
        mFunctions.insert(846, std::bind(&Gles::callGlLoadMatrixf, this, _1, _2));
        mFunctions.insert(847, std::bind(&Gles::callGlLoadMatrixx, this, _1, _2));
        mFunctions.insert(848, std::bind(&Gles::callGlLoadMatrixxOES, this, _1, _2));
        mFunctions.insert(849, std::bind(&Gles::callGlLoadPaletteFromModelViewMatrixOES, this, _1, _2));
        mFunctions.insert(850, std::bind(&Gles::callGlLogicOp, this, _1, _2));
        mFunctions.insert(851, std::bind(&Gles::callGlMaterialf, this, _1, _2));
        mFunctions.insert(852, std::bind(&Gles::callGlMaterialfv, this, _1, _2));
        mFunctions.insert(853, std::bind(&Gles::callGlMaterialx, this, _1, _2));
        mFunctions.insert(854, std::bind(&Gles::callGlMaterialxOES, this, _1, _2));
        mFunctions.insert(855, std::bind(&Gles::callGlMaterialxv, this, _1, _2));
        mFunctions.insert(856, std::bind(&Gles::callGlMaterialxvOES, this, _1, _2));
        mFunctions.insert(857, std::bind(&Gles::callGlMatrixIndexPointerOES, this, _1, _2));
        mFunctions.insert(858, std::bind(&Gles::callGlMatrixMode, this, _1, _2));
        mFunctions.insert(859, std::bind(&Gles::callGlMultMatrixf, this, _1, _2));
        mFunctions.insert(860, std::bind(&Gles::callGlMultMatrixx, this, _1, _2));
        mFunctions.insert(861, std::bind(&Gles::callGlMultMatrixxOES, this, _1, _2));
        mFunctions.insert(862, std::bind(&Gles::callGlMultiTexCoord4f, this, _1, _2));
        mFunctions.insert(863, std::bind(&Gles::callGlMultiTexCoord4x, this, _1, _2));
        mFunctions.insert(864, std::bind(&Gles::callGlMultiTexCoord4xOES, this, _1, _2));
        mFunctions.insert(865, std::bind(&Gles::callGlNormal3f, this, _1, _2));
        mFunctions.insert(866, std::bind(&Gles::callGlNormal3x, this, _1, _2));
        mFunctions.insert(867, std::bind(&Gles::callGlNormal3xOES, this, _1, _2));
        mFunctions.insert(868, std::bind(&Gles::callGlNormalPointer, this, _1, _2));
        mFunctions.insert(869, std::bind(&Gles::callGlOrthof, this, _1, _2));
        mFunctions.insert(870, std::bind(&Gles::callGlOrthofOES, this, _1, _2));
        mFunctions.insert(871, std::bind(&Gles::callGlOrthox, this, _1, _2));
        mFunctions.insert(872, std::bind(&Gles::callGlOrthoxOES, this, _1, _2));
        mFunctions.insert(873, std::bind(&Gles::callGlPointParameterf, this, _1, _2));
        mFunctions.insert(874, std::bind(&Gles::callGlPointParameterfv, this, _1, _2));
        mFunctions.insert(875, std::bind(&Gles::callGlPointParameterx, this, _1, _2));
        mFunctions.insert(876, std::bind(&Gles::callGlPointParameterxOES, this, _1, _2));
        mFunctions.insert(877, std::bind(&Gles::callGlPointParameterxv, this, _1, _2));
        mFunctions.insert(878, std::bind(&Gles::callGlPointParameterxvOES, this, _1, _2));
        mFunctions.insert(879, std::bind(&Gles::callGlPointSize, this, _1, _2));
        mFunctions.insert(880, std::bind(&Gles::callGlPointSizePointerOES, this, _1, _2));
        mFunctions.insert(881, std::bind(&Gles::callGlPointSizex, this, _1, _2));
        mFunctions.insert(882, std::bind(&Gles::callGlPointSizexOES, this, _1, _2));
        mFunctions.insert(883, std::bind(&Gles::callGlPolygonOffsetx, this, _1, _2));
        mFunctions.insert(884, std::bind(&Gles::callGlPolygonOffsetxOES, this, _1, _2));
        mFunctions.insert(885, std::bind(&Gles::callGlPopMatrix, this, _1, _2));
        mFunctions.insert(886, std::bind(&Gles::callGlPushMatrix, this, _1, _2));
        mFunctions.insert(887, std::bind(&Gles::callGlQueryMatrixxOES, this, _1, _2));
        mFunctions.insert(888, std::bind(&Gles::callGlRenderbufferStorageOES, this, _1, _2));
        mFunctions.insert(889, std::bind(&Gles::callGlRotatef, this, _1, _2));
        mFunctions.insert(890, std::bind(&Gles::callGlRotatex, this, _1, _2));
        mFunctions.insert(891, std::bind(&Gles::callGlRotatexOES, this, _1, _2));
        mFunctions.insert(892, std::bind(&Gles::callGlSampleCoveragex, this, _1, _2));
        mFunctions.insert(893, std::bind(&Gles::callGlSampleCoveragexOES, this, _1, _2));
        mFunctions.insert(894, std::bind(&Gles::callGlScalef, this, _1, _2));
        mFunctions.insert(895, std::bind(&Gles::callGlScalex, this, _1, _2));
        mFunctions.insert(896, std::bind(&Gles::callGlScalexOES, this, _1, _2));
        mFunctions.insert(897, std::bind(&Gles::callGlShadeModel, this, _1, _2));
        mFunctions.insert(898, std::bind(&Gles::callGlTexCoordPointer, this, _1, _2));
        mFunctions.insert(899, std::bind(&Gles::callGlTexEnvf, this, _1, _2));
        mFunctions.insert(900, std::bind(&Gles::callGlTexEnvfv, this, _1, _2));
        mFunctions.insert(901, std::bind(&Gles::callGlTexEnvi, this, _1, _2));
        mFunctions.insert(902, std::bind(&Gles::callGlTexEnviv, this, _1, _2));
        mFunctions.insert(903, std::bind(&Gles::callGlTexEnvx, this, _1, _2));
        mFunctions.insert(904, std::bind(&Gles::callGlTexEnvxOES, this, _1, _2));
        mFunctions.insert(905, std::bind(&Gles::callGlTexEnvxv, this, _1, _2));
        mFunctions.insert(906, std::bind(&Gles::callGlTexEnvxvOES, this, _1, _2));
        mFunctions.insert(907, std::bind(&Gles::callGlTexGenfOES, this, _1, _2));
        mFunctions.insert(908, std::bind(&Gles::callGlTexGenfvOES, this, _1, _2));
        mFunctions.insert(909, std::bind(&Gles::callGlTexGeniOES, this, _1, _2));
        mFunctions.insert(910, std::bind(&Gles::callGlTexGenivOES, this, _1, _2));
        mFunctions.insert(911, std::bind(&Gles::callGlTexGenxOES, this, _1, _2));
        mFunctions.insert(912, std::bind(&Gles::callGlTexGenxvOES, this, _1, _2));
        mFunctions.insert(913, std::bind(&Gles::callGlTexParameterx, this, _1, _2));
        mFunctions.insert(914, std::bind(&Gles::callGlTexParameterxOES, this, _1, _2));
        mFunctions.insert(915, std::bind(&Gles::callGlTexParameterxv, this, _1, _2));
        mFunctions.insert(916, std::bind(&Gles::callGlTexParameterxvOES, this, _1, _2));
        mFunctions.insert(917, std::bind(&Gles::callGlTranslatef, this, _1, _2));
        mFunctions.insert(918, std::bind(&Gles::callGlTranslatex, this, _1, _2));
        mFunctions.insert(919, std::bind(&Gles::callGlTranslatexOES, this, _1, _2));
        mFunctions.insert(920, std::bind(&Gles::callGlVertexPointer, this, _1, _2));
        mFunctions.insert(921, std::bind(&Gles::callGlWeightPointerOES, this, _1, _2));
        mFunctions.insert(922, std::bind(&Gles::callGlColorPointerBounds, this, _1, _2));
        mFunctions.insert(923, std::bind(&Gles::callGlNormalPointerBounds, this, _1, _2));
        mFunctions.insert(924, std::bind(&Gles::callGlTexCoordPointerBounds, this, _1, _2));
        mFunctions.insert(925, std::bind(&Gles::callGlVertexPointerBounds, this, _1, _2));
        mFunctions.insert(926, std::bind(&Gles::callGlPointSizePointerOESBounds, this, _1, _2));
        mFunctions.insert(927, std::bind(&Gles::callGlMatrixIndexPointerOESBounds, this, _1, _2));
        mFunctions.insert(928, std::bind(&Gles::callGlWeightPointerOESBounds, this, _1, _2));
    }

    void Gles::resolve() {
        glBlendBarrierKHR = reinterpret_cast<PFNGLBLENDBARRIERKHR>(gapic::GetGfxProcAddress("glBlendBarrierKHR", false));
        glBlendEquationSeparateiEXT = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEIEXT>(gapic::GetGfxProcAddress("glBlendEquationSeparateiEXT", false));
        glBlendEquationiEXT = reinterpret_cast<PFNGLBLENDEQUATIONIEXT>(gapic::GetGfxProcAddress("glBlendEquationiEXT", false));
        glBlendFuncSeparateiEXT = reinterpret_cast<PFNGLBLENDFUNCSEPARATEIEXT>(gapic::GetGfxProcAddress("glBlendFuncSeparateiEXT", false));
        glBlendFunciEXT = reinterpret_cast<PFNGLBLENDFUNCIEXT>(gapic::GetGfxProcAddress("glBlendFunciEXT", false));
        glColorMaskiEXT = reinterpret_cast<PFNGLCOLORMASKIEXT>(gapic::GetGfxProcAddress("glColorMaskiEXT", false));
        glCopyImageSubDataEXT = reinterpret_cast<PFNGLCOPYIMAGESUBDATAEXT>(gapic::GetGfxProcAddress("glCopyImageSubDataEXT", false));
        glDebugMessageCallbackKHR = reinterpret_cast<PFNGLDEBUGMESSAGECALLBACKKHR>(gapic::GetGfxProcAddress("glDebugMessageCallbackKHR", false));
        glDebugMessageControlKHR = reinterpret_cast<PFNGLDEBUGMESSAGECONTROLKHR>(gapic::GetGfxProcAddress("glDebugMessageControlKHR", false));
        glDebugMessageInsertKHR = reinterpret_cast<PFNGLDEBUGMESSAGEINSERTKHR>(gapic::GetGfxProcAddress("glDebugMessageInsertKHR", false));
        glDisableiEXT = reinterpret_cast<PFNGLDISABLEIEXT>(gapic::GetGfxProcAddress("glDisableiEXT", false));
        glEnableiEXT = reinterpret_cast<PFNGLENABLEIEXT>(gapic::GetGfxProcAddress("glEnableiEXT", false));
        glFramebufferTextureEXT = reinterpret_cast<PFNGLFRAMEBUFFERTEXTUREEXT>(gapic::GetGfxProcAddress("glFramebufferTextureEXT", false));
        glGetDebugMessageLogKHR = reinterpret_cast<PFNGLGETDEBUGMESSAGELOGKHR>(gapic::GetGfxProcAddress("glGetDebugMessageLogKHR", false));
        glGetObjectLabelKHR = reinterpret_cast<PFNGLGETOBJECTLABELKHR>(gapic::GetGfxProcAddress("glGetObjectLabelKHR", false));
        glGetObjectPtrLabelKHR = reinterpret_cast<PFNGLGETOBJECTPTRLABELKHR>(gapic::GetGfxProcAddress("glGetObjectPtrLabelKHR", false));
        glGetPointervKHR = reinterpret_cast<PFNGLGETPOINTERVKHR>(gapic::GetGfxProcAddress("glGetPointervKHR", false));
        glGetSamplerParameterIivEXT = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIIVEXT>(gapic::GetGfxProcAddress("glGetSamplerParameterIivEXT", false));
        glGetSamplerParameterIuivEXT = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIUIVEXT>(gapic::GetGfxProcAddress("glGetSamplerParameterIuivEXT", false));
        glGetTexParameterIivEXT = reinterpret_cast<PFNGLGETTEXPARAMETERIIVEXT>(gapic::GetGfxProcAddress("glGetTexParameterIivEXT", false));
        glGetTexParameterIuivEXT = reinterpret_cast<PFNGLGETTEXPARAMETERIUIVEXT>(gapic::GetGfxProcAddress("glGetTexParameterIuivEXT", false));
        glIsEnablediEXT = reinterpret_cast<PFNGLISENABLEDIEXT>(gapic::GetGfxProcAddress("glIsEnablediEXT", false));
        glMinSampleShadingOES = reinterpret_cast<PFNGLMINSAMPLESHADINGOES>(gapic::GetGfxProcAddress("glMinSampleShadingOES", false));
        glObjectLabelKHR = reinterpret_cast<PFNGLOBJECTLABELKHR>(gapic::GetGfxProcAddress("glObjectLabelKHR", false));
        glObjectPtrLabelKHR = reinterpret_cast<PFNGLOBJECTPTRLABELKHR>(gapic::GetGfxProcAddress("glObjectPtrLabelKHR", false));
        glPatchParameteriEXT = reinterpret_cast<PFNGLPATCHPARAMETERIEXT>(gapic::GetGfxProcAddress("glPatchParameteriEXT", false));
        glPopDebugGroupKHR = reinterpret_cast<PFNGLPOPDEBUGGROUPKHR>(gapic::GetGfxProcAddress("glPopDebugGroupKHR", false));
        glPrimitiveBoundingBoxEXT = reinterpret_cast<PFNGLPRIMITIVEBOUNDINGBOXEXT>(gapic::GetGfxProcAddress("glPrimitiveBoundingBoxEXT", false));
        glPushDebugGroupKHR = reinterpret_cast<PFNGLPUSHDEBUGGROUPKHR>(gapic::GetGfxProcAddress("glPushDebugGroupKHR", false));
        glSamplerParameterIivEXT = reinterpret_cast<PFNGLSAMPLERPARAMETERIIVEXT>(gapic::GetGfxProcAddress("glSamplerParameterIivEXT", false));
        glSamplerParameterIuivEXT = reinterpret_cast<PFNGLSAMPLERPARAMETERIUIVEXT>(gapic::GetGfxProcAddress("glSamplerParameterIuivEXT", false));
        glTexBufferEXT = reinterpret_cast<PFNGLTEXBUFFEREXT>(gapic::GetGfxProcAddress("glTexBufferEXT", false));
        glTexBufferRangeEXT = reinterpret_cast<PFNGLTEXBUFFERRANGEEXT>(gapic::GetGfxProcAddress("glTexBufferRangeEXT", false));
        glTexParameterIivEXT = reinterpret_cast<PFNGLTEXPARAMETERIIVEXT>(gapic::GetGfxProcAddress("glTexParameterIivEXT", false));
        glTexParameterIuivEXT = reinterpret_cast<PFNGLTEXPARAMETERIUIVEXT>(gapic::GetGfxProcAddress("glTexParameterIuivEXT", false));
        glTexStorage3DMultisampleOES = reinterpret_cast<PFNGLTEXSTORAGE3DMULTISAMPLEOES>(gapic::GetGfxProcAddress("glTexStorage3DMultisampleOES", false));
        glBeginQuery = reinterpret_cast<PFNGLBEGINQUERY>(gapic::GetGfxProcAddress("glBeginQuery", false));
        glDeleteQueries = reinterpret_cast<PFNGLDELETEQUERIES>(gapic::GetGfxProcAddress("glDeleteQueries", false));
        glEndQuery = reinterpret_cast<PFNGLENDQUERY>(gapic::GetGfxProcAddress("glEndQuery", false));
        glGenQueries = reinterpret_cast<PFNGLGENQUERIES>(gapic::GetGfxProcAddress("glGenQueries", false));
        glGetQueryObjectuiv = reinterpret_cast<PFNGLGETQUERYOBJECTUIV>(gapic::GetGfxProcAddress("glGetQueryObjectuiv", false));
        glGetQueryiv = reinterpret_cast<PFNGLGETQUERYIV>(gapic::GetGfxProcAddress("glGetQueryiv", false));
        glIsQuery = reinterpret_cast<PFNGLISQUERY>(gapic::GetGfxProcAddress("glIsQuery", false));
        glBindBuffer = reinterpret_cast<PFNGLBINDBUFFER>(gapic::GetGfxProcAddress("glBindBuffer", false));
        glBindBufferBase = reinterpret_cast<PFNGLBINDBUFFERBASE>(gapic::GetGfxProcAddress("glBindBufferBase", false));
        glBindBufferRange = reinterpret_cast<PFNGLBINDBUFFERRANGE>(gapic::GetGfxProcAddress("glBindBufferRange", false));
        glBufferData = reinterpret_cast<PFNGLBUFFERDATA>(gapic::GetGfxProcAddress("glBufferData", false));
        glBufferSubData = reinterpret_cast<PFNGLBUFFERSUBDATA>(gapic::GetGfxProcAddress("glBufferSubData", false));
        glCopyBufferSubData = reinterpret_cast<PFNGLCOPYBUFFERSUBDATA>(gapic::GetGfxProcAddress("glCopyBufferSubData", false));
        glDeleteBuffers = reinterpret_cast<PFNGLDELETEBUFFERS>(gapic::GetGfxProcAddress("glDeleteBuffers", false));
        glGenBuffers = reinterpret_cast<PFNGLGENBUFFERS>(gapic::GetGfxProcAddress("glGenBuffers", false));
        glGetBufferParameteri64v = reinterpret_cast<PFNGLGETBUFFERPARAMETERI64V>(gapic::GetGfxProcAddress("glGetBufferParameteri64v", false));
        glGetBufferParameteriv = reinterpret_cast<PFNGLGETBUFFERPARAMETERIV>(gapic::GetGfxProcAddress("glGetBufferParameteriv", false));
        glGetBufferPointerv = reinterpret_cast<PFNGLGETBUFFERPOINTERV>(gapic::GetGfxProcAddress("glGetBufferPointerv", false));
        glIsBuffer = reinterpret_cast<PFNGLISBUFFER>(gapic::GetGfxProcAddress("glIsBuffer", false));
        glMapBufferRange = reinterpret_cast<PFNGLMAPBUFFERRANGE>(gapic::GetGfxProcAddress("glMapBufferRange", false));
        glUnmapBuffer = reinterpret_cast<PFNGLUNMAPBUFFER>(gapic::GetGfxProcAddress("glUnmapBuffer", false));
        glDebugMessageCallback = reinterpret_cast<PFNGLDEBUGMESSAGECALLBACK>(gapic::GetGfxProcAddress("glDebugMessageCallback", false));
        glDebugMessageControl = reinterpret_cast<PFNGLDEBUGMESSAGECONTROL>(gapic::GetGfxProcAddress("glDebugMessageControl", false));
        glDebugMessageInsert = reinterpret_cast<PFNGLDEBUGMESSAGEINSERT>(gapic::GetGfxProcAddress("glDebugMessageInsert", false));
        glGetDebugMessageLog = reinterpret_cast<PFNGLGETDEBUGMESSAGELOG>(gapic::GetGfxProcAddress("glGetDebugMessageLog", false));
        glGetObjectLabel = reinterpret_cast<PFNGLGETOBJECTLABEL>(gapic::GetGfxProcAddress("glGetObjectLabel", false));
        glGetObjectPtrLabel = reinterpret_cast<PFNGLGETOBJECTPTRLABEL>(gapic::GetGfxProcAddress("glGetObjectPtrLabel", false));
        glGetPointerv = reinterpret_cast<PFNGLGETPOINTERV>(gapic::GetGfxProcAddress("glGetPointerv", false));
        glObjectLabel = reinterpret_cast<PFNGLOBJECTLABEL>(gapic::GetGfxProcAddress("glObjectLabel", false));
        glObjectPtrLabel = reinterpret_cast<PFNGLOBJECTPTRLABEL>(gapic::GetGfxProcAddress("glObjectPtrLabel", false));
        glPopDebugGroup = reinterpret_cast<PFNGLPOPDEBUGGROUP>(gapic::GetGfxProcAddress("glPopDebugGroup", false));
        glPushDebugGroup = reinterpret_cast<PFNGLPUSHDEBUGGROUP>(gapic::GetGfxProcAddress("glPushDebugGroup", false));
        glDrawArrays = reinterpret_cast<PFNGLDRAWARRAYS>(gapic::GetGfxProcAddress("glDrawArrays", false));
        glDrawArraysIndirect = reinterpret_cast<PFNGLDRAWARRAYSINDIRECT>(gapic::GetGfxProcAddress("glDrawArraysIndirect", false));
        glDrawArraysInstanced = reinterpret_cast<PFNGLDRAWARRAYSINSTANCED>(gapic::GetGfxProcAddress("glDrawArraysInstanced", false));
        glDrawElements = reinterpret_cast<PFNGLDRAWELEMENTS>(gapic::GetGfxProcAddress("glDrawElements", false));
        glDrawElementsBaseVertex = reinterpret_cast<PFNGLDRAWELEMENTSBASEVERTEX>(gapic::GetGfxProcAddress("glDrawElementsBaseVertex", false));
        glDrawElementsIndirect = reinterpret_cast<PFNGLDRAWELEMENTSINDIRECT>(gapic::GetGfxProcAddress("glDrawElementsIndirect", false));
        glDrawElementsInstanced = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCED>(gapic::GetGfxProcAddress("glDrawElementsInstanced", false));
        glDrawElementsInstancedBaseVertex = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX>(gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertex", false));
        glDrawRangeElements = reinterpret_cast<PFNGLDRAWRANGEELEMENTS>(gapic::GetGfxProcAddress("glDrawRangeElements", false));
        glDrawRangeElementsBaseVertex = reinterpret_cast<PFNGLDRAWRANGEELEMENTSBASEVERTEX>(gapic::GetGfxProcAddress("glDrawRangeElementsBaseVertex", false));
        glPatchParameteri = reinterpret_cast<PFNGLPATCHPARAMETERI>(gapic::GetGfxProcAddress("glPatchParameteri", false));
        glPrimitiveBoundingBox = reinterpret_cast<PFNGLPRIMITIVEBOUNDINGBOX>(gapic::GetGfxProcAddress("glPrimitiveBoundingBox", false));
        glActiveShaderProgramEXT = reinterpret_cast<PFNGLACTIVESHADERPROGRAMEXT>(gapic::GetGfxProcAddress("glActiveShaderProgramEXT", false));
        glAlphaFuncQCOM = reinterpret_cast<PFNGLALPHAFUNCQCOM>(gapic::GetGfxProcAddress("glAlphaFuncQCOM", false));
        glApplyFramebufferAttachmentCMAAINTEL = reinterpret_cast<PFNGLAPPLYFRAMEBUFFERATTACHMENTCMAAINTEL>(gapic::GetGfxProcAddress("glApplyFramebufferAttachmentCMAAINTEL", false));
        glBeginConditionalRenderNV = reinterpret_cast<PFNGLBEGINCONDITIONALRENDERNV>(gapic::GetGfxProcAddress("glBeginConditionalRenderNV", false));
        glBeginPerfMonitorAMD = reinterpret_cast<PFNGLBEGINPERFMONITORAMD>(gapic::GetGfxProcAddress("glBeginPerfMonitorAMD", false));
        glBeginPerfQueryINTEL = reinterpret_cast<PFNGLBEGINPERFQUERYINTEL>(gapic::GetGfxProcAddress("glBeginPerfQueryINTEL", false));
        glBeginQueryEXT = reinterpret_cast<PFNGLBEGINQUERYEXT>(gapic::GetGfxProcAddress("glBeginQueryEXT", false));
        glBindFragDataLocationEXT = reinterpret_cast<PFNGLBINDFRAGDATALOCATIONEXT>(gapic::GetGfxProcAddress("glBindFragDataLocationEXT", false));
        glBindFragDataLocationIndexedEXT = reinterpret_cast<PFNGLBINDFRAGDATALOCATIONINDEXEDEXT>(gapic::GetGfxProcAddress("glBindFragDataLocationIndexedEXT", false));
        glBindProgramPipelineEXT = reinterpret_cast<PFNGLBINDPROGRAMPIPELINEEXT>(gapic::GetGfxProcAddress("glBindProgramPipelineEXT", false));
        glBindVertexArrayOES = reinterpret_cast<PFNGLBINDVERTEXARRAYOES>(gapic::GetGfxProcAddress("glBindVertexArrayOES", false));
        glBlendBarrierNV = reinterpret_cast<PFNGLBLENDBARRIERNV>(gapic::GetGfxProcAddress("glBlendBarrierNV", false));
        glBlendEquationSeparateiOES = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEIOES>(gapic::GetGfxProcAddress("glBlendEquationSeparateiOES", false));
        glBlendEquationiOES = reinterpret_cast<PFNGLBLENDEQUATIONIOES>(gapic::GetGfxProcAddress("glBlendEquationiOES", false));
        glBlendFuncSeparateiOES = reinterpret_cast<PFNGLBLENDFUNCSEPARATEIOES>(gapic::GetGfxProcAddress("glBlendFuncSeparateiOES", false));
        glBlendFunciOES = reinterpret_cast<PFNGLBLENDFUNCIOES>(gapic::GetGfxProcAddress("glBlendFunciOES", false));
        glBlendParameteriNV = reinterpret_cast<PFNGLBLENDPARAMETERINV>(gapic::GetGfxProcAddress("glBlendParameteriNV", false));
        glBlitFramebufferANGLE = reinterpret_cast<PFNGLBLITFRAMEBUFFERANGLE>(gapic::GetGfxProcAddress("glBlitFramebufferANGLE", false));
        glBlitFramebufferNV = reinterpret_cast<PFNGLBLITFRAMEBUFFERNV>(gapic::GetGfxProcAddress("glBlitFramebufferNV", false));
        glBufferStorageEXT = reinterpret_cast<PFNGLBUFFERSTORAGEEXT>(gapic::GetGfxProcAddress("glBufferStorageEXT", false));
        glClientWaitSyncAPPLE = reinterpret_cast<PFNGLCLIENTWAITSYNCAPPLE>(gapic::GetGfxProcAddress("glClientWaitSyncAPPLE", false));
        glColorMaskiOES = reinterpret_cast<PFNGLCOLORMASKIOES>(gapic::GetGfxProcAddress("glColorMaskiOES", false));
        glCompressedTexImage3DOES = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE3DOES>(gapic::GetGfxProcAddress("glCompressedTexImage3DOES", false));
        glCompressedTexSubImage3DOES = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE3DOES>(gapic::GetGfxProcAddress("glCompressedTexSubImage3DOES", false));
        glCopyBufferSubDataNV = reinterpret_cast<PFNGLCOPYBUFFERSUBDATANV>(gapic::GetGfxProcAddress("glCopyBufferSubDataNV", false));
        glCopyImageSubDataOES = reinterpret_cast<PFNGLCOPYIMAGESUBDATAOES>(gapic::GetGfxProcAddress("glCopyImageSubDataOES", false));
        glCopyPathNV = reinterpret_cast<PFNGLCOPYPATHNV>(gapic::GetGfxProcAddress("glCopyPathNV", false));
        glCopyTexSubImage3DOES = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE3DOES>(gapic::GetGfxProcAddress("glCopyTexSubImage3DOES", false));
        glCopyTextureLevelsAPPLE = reinterpret_cast<PFNGLCOPYTEXTURELEVELSAPPLE>(gapic::GetGfxProcAddress("glCopyTextureLevelsAPPLE", false));
        glCoverFillPathInstancedNV = reinterpret_cast<PFNGLCOVERFILLPATHINSTANCEDNV>(gapic::GetGfxProcAddress("glCoverFillPathInstancedNV", false));
        glCoverFillPathNV = reinterpret_cast<PFNGLCOVERFILLPATHNV>(gapic::GetGfxProcAddress("glCoverFillPathNV", false));
        glCoverStrokePathInstancedNV = reinterpret_cast<PFNGLCOVERSTROKEPATHINSTANCEDNV>(gapic::GetGfxProcAddress("glCoverStrokePathInstancedNV", false));
        glCoverStrokePathNV = reinterpret_cast<PFNGLCOVERSTROKEPATHNV>(gapic::GetGfxProcAddress("glCoverStrokePathNV", false));
        glCoverageMaskNV = reinterpret_cast<PFNGLCOVERAGEMASKNV>(gapic::GetGfxProcAddress("glCoverageMaskNV", false));
        glCoverageModulationNV = reinterpret_cast<PFNGLCOVERAGEMODULATIONNV>(gapic::GetGfxProcAddress("glCoverageModulationNV", false));
        glCoverageModulationTableNV = reinterpret_cast<PFNGLCOVERAGEMODULATIONTABLENV>(gapic::GetGfxProcAddress("glCoverageModulationTableNV", false));
        glCoverageOperationNV = reinterpret_cast<PFNGLCOVERAGEOPERATIONNV>(gapic::GetGfxProcAddress("glCoverageOperationNV", false));
        glCreatePerfQueryINTEL = reinterpret_cast<PFNGLCREATEPERFQUERYINTEL>(gapic::GetGfxProcAddress("glCreatePerfQueryINTEL", false));
        glCreateShaderProgramvEXT = reinterpret_cast<PFNGLCREATESHADERPROGRAMVEXT>(gapic::GetGfxProcAddress("glCreateShaderProgramvEXT", false));
        glDeleteFencesNV = reinterpret_cast<PFNGLDELETEFENCESNV>(gapic::GetGfxProcAddress("glDeleteFencesNV", false));
        glDeletePathsNV = reinterpret_cast<PFNGLDELETEPATHSNV>(gapic::GetGfxProcAddress("glDeletePathsNV", false));
        glDeletePerfMonitorsAMD = reinterpret_cast<PFNGLDELETEPERFMONITORSAMD>(gapic::GetGfxProcAddress("glDeletePerfMonitorsAMD", false));
        glDeletePerfQueryINTEL = reinterpret_cast<PFNGLDELETEPERFQUERYINTEL>(gapic::GetGfxProcAddress("glDeletePerfQueryINTEL", false));
        glDeleteProgramPipelinesEXT = reinterpret_cast<PFNGLDELETEPROGRAMPIPELINESEXT>(gapic::GetGfxProcAddress("glDeleteProgramPipelinesEXT", false));
        glDeleteQueriesEXT = reinterpret_cast<PFNGLDELETEQUERIESEXT>(gapic::GetGfxProcAddress("glDeleteQueriesEXT", false));
        glDeleteSyncAPPLE = reinterpret_cast<PFNGLDELETESYNCAPPLE>(gapic::GetGfxProcAddress("glDeleteSyncAPPLE", false));
        glDeleteVertexArraysOES = reinterpret_cast<PFNGLDELETEVERTEXARRAYSOES>(gapic::GetGfxProcAddress("glDeleteVertexArraysOES", false));
        glDepthRangeArrayfvNV = reinterpret_cast<PFNGLDEPTHRANGEARRAYFVNV>(gapic::GetGfxProcAddress("glDepthRangeArrayfvNV", false));
        glDepthRangeIndexedfNV = reinterpret_cast<PFNGLDEPTHRANGEINDEXEDFNV>(gapic::GetGfxProcAddress("glDepthRangeIndexedfNV", false));
        glDisableDriverControlQCOM = reinterpret_cast<PFNGLDISABLEDRIVERCONTROLQCOM>(gapic::GetGfxProcAddress("glDisableDriverControlQCOM", false));
        glDisableiNV = reinterpret_cast<PFNGLDISABLEINV>(gapic::GetGfxProcAddress("glDisableiNV", false));
        glDisableiOES = reinterpret_cast<PFNGLDISABLEIOES>(gapic::GetGfxProcAddress("glDisableiOES", false));
        glDiscardFramebufferEXT = reinterpret_cast<PFNGLDISCARDFRAMEBUFFEREXT>(gapic::GetGfxProcAddress("glDiscardFramebufferEXT", false));
        glDrawArraysInstancedANGLE = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDANGLE>(gapic::GetGfxProcAddress("glDrawArraysInstancedANGLE", false));
        glDrawArraysInstancedBaseInstanceEXT = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXT>(gapic::GetGfxProcAddress("glDrawArraysInstancedBaseInstanceEXT", false));
        glDrawArraysInstancedEXT = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDEXT>(gapic::GetGfxProcAddress("glDrawArraysInstancedEXT", false));
        glDrawArraysInstancedNV = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDNV>(gapic::GetGfxProcAddress("glDrawArraysInstancedNV", false));
        glDrawBuffersEXT = reinterpret_cast<PFNGLDRAWBUFFERSEXT>(gapic::GetGfxProcAddress("glDrawBuffersEXT", false));
        glDrawBuffersIndexedEXT = reinterpret_cast<PFNGLDRAWBUFFERSINDEXEDEXT>(gapic::GetGfxProcAddress("glDrawBuffersIndexedEXT", false));
        glDrawBuffersNV = reinterpret_cast<PFNGLDRAWBUFFERSNV>(gapic::GetGfxProcAddress("glDrawBuffersNV", false));
        glDrawElementsBaseVertexEXT = reinterpret_cast<PFNGLDRAWELEMENTSBASEVERTEXEXT>(gapic::GetGfxProcAddress("glDrawElementsBaseVertexEXT", false));
        glDrawElementsBaseVertexOES = reinterpret_cast<PFNGLDRAWELEMENTSBASEVERTEXOES>(gapic::GetGfxProcAddress("glDrawElementsBaseVertexOES", false));
        glDrawElementsInstancedANGLE = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDANGLE>(gapic::GetGfxProcAddress("glDrawElementsInstancedANGLE", false));
        glDrawElementsInstancedBaseInstanceEXT = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXT>(gapic::GetGfxProcAddress("glDrawElementsInstancedBaseInstanceEXT", false));
        glDrawElementsInstancedBaseVertexBaseInstanceEXT = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXT>(gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertexBaseInstanceEXT", false));
        glDrawElementsInstancedBaseVertexEXT = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXT>(gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertexEXT", false));
        glDrawElementsInstancedBaseVertexOES = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXOES>(gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertexOES", false));
        glDrawElementsInstancedEXT = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDEXT>(gapic::GetGfxProcAddress("glDrawElementsInstancedEXT", false));
        glDrawElementsInstancedNV = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDNV>(gapic::GetGfxProcAddress("glDrawElementsInstancedNV", false));
        glDrawRangeElementsBaseVertexEXT = reinterpret_cast<PFNGLDRAWRANGEELEMENTSBASEVERTEXEXT>(gapic::GetGfxProcAddress("glDrawRangeElementsBaseVertexEXT", false));
        glDrawRangeElementsBaseVertexOES = reinterpret_cast<PFNGLDRAWRANGEELEMENTSBASEVERTEXOES>(gapic::GetGfxProcAddress("glDrawRangeElementsBaseVertexOES", false));
        glEGLImageTargetRenderbufferStorageOES = reinterpret_cast<PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOES>(gapic::GetGfxProcAddress("glEGLImageTargetRenderbufferStorageOES", false));
        glEGLImageTargetTexture2DOES = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOES>(gapic::GetGfxProcAddress("glEGLImageTargetTexture2DOES", false));
        glEnableDriverControlQCOM = reinterpret_cast<PFNGLENABLEDRIVERCONTROLQCOM>(gapic::GetGfxProcAddress("glEnableDriverControlQCOM", false));
        glEnableiNV = reinterpret_cast<PFNGLENABLEINV>(gapic::GetGfxProcAddress("glEnableiNV", false));
        glEnableiOES = reinterpret_cast<PFNGLENABLEIOES>(gapic::GetGfxProcAddress("glEnableiOES", false));
        glEndConditionalRenderNV = reinterpret_cast<PFNGLENDCONDITIONALRENDERNV>(gapic::GetGfxProcAddress("glEndConditionalRenderNV", false));
        glEndPerfMonitorAMD = reinterpret_cast<PFNGLENDPERFMONITORAMD>(gapic::GetGfxProcAddress("glEndPerfMonitorAMD", false));
        glEndPerfQueryINTEL = reinterpret_cast<PFNGLENDPERFQUERYINTEL>(gapic::GetGfxProcAddress("glEndPerfQueryINTEL", false));
        glEndQueryEXT = reinterpret_cast<PFNGLENDQUERYEXT>(gapic::GetGfxProcAddress("glEndQueryEXT", false));
        glEndTilingQCOM = reinterpret_cast<PFNGLENDTILINGQCOM>(gapic::GetGfxProcAddress("glEndTilingQCOM", false));
        glExtGetBufferPointervQCOM = reinterpret_cast<PFNGLEXTGETBUFFERPOINTERVQCOM>(gapic::GetGfxProcAddress("glExtGetBufferPointervQCOM", false));
        glExtGetBuffersQCOM = reinterpret_cast<PFNGLEXTGETBUFFERSQCOM>(gapic::GetGfxProcAddress("glExtGetBuffersQCOM", false));
        glExtGetFramebuffersQCOM = reinterpret_cast<PFNGLEXTGETFRAMEBUFFERSQCOM>(gapic::GetGfxProcAddress("glExtGetFramebuffersQCOM", false));
        glExtGetProgramBinarySourceQCOM = reinterpret_cast<PFNGLEXTGETPROGRAMBINARYSOURCEQCOM>(gapic::GetGfxProcAddress("glExtGetProgramBinarySourceQCOM", false));
        glExtGetProgramsQCOM = reinterpret_cast<PFNGLEXTGETPROGRAMSQCOM>(gapic::GetGfxProcAddress("glExtGetProgramsQCOM", false));
        glExtGetRenderbuffersQCOM = reinterpret_cast<PFNGLEXTGETRENDERBUFFERSQCOM>(gapic::GetGfxProcAddress("glExtGetRenderbuffersQCOM", false));
        glExtGetShadersQCOM = reinterpret_cast<PFNGLEXTGETSHADERSQCOM>(gapic::GetGfxProcAddress("glExtGetShadersQCOM", false));
        glExtGetTexLevelParameterivQCOM = reinterpret_cast<PFNGLEXTGETTEXLEVELPARAMETERIVQCOM>(gapic::GetGfxProcAddress("glExtGetTexLevelParameterivQCOM", false));
        glExtGetTexSubImageQCOM = reinterpret_cast<PFNGLEXTGETTEXSUBIMAGEQCOM>(gapic::GetGfxProcAddress("glExtGetTexSubImageQCOM", false));
        glExtGetTexturesQCOM = reinterpret_cast<PFNGLEXTGETTEXTURESQCOM>(gapic::GetGfxProcAddress("glExtGetTexturesQCOM", false));
        glExtIsProgramBinaryQCOM = reinterpret_cast<PFNGLEXTISPROGRAMBINARYQCOM>(gapic::GetGfxProcAddress("glExtIsProgramBinaryQCOM", false));
        glExtTexObjectStateOverrideiQCOM = reinterpret_cast<PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOM>(gapic::GetGfxProcAddress("glExtTexObjectStateOverrideiQCOM", false));
        glFenceSyncAPPLE = reinterpret_cast<PFNGLFENCESYNCAPPLE>(gapic::GetGfxProcAddress("glFenceSyncAPPLE", false));
        glFinishFenceNV = reinterpret_cast<PFNGLFINISHFENCENV>(gapic::GetGfxProcAddress("glFinishFenceNV", false));
        glFlushMappedBufferRangeEXT = reinterpret_cast<PFNGLFLUSHMAPPEDBUFFERRANGEEXT>(gapic::GetGfxProcAddress("glFlushMappedBufferRangeEXT", false));
        glFragmentCoverageColorNV = reinterpret_cast<PFNGLFRAGMENTCOVERAGECOLORNV>(gapic::GetGfxProcAddress("glFragmentCoverageColorNV", false));
        glFramebufferSampleLocationsfvNV = reinterpret_cast<PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNV>(gapic::GetGfxProcAddress("glFramebufferSampleLocationsfvNV", false));
        glFramebufferTexture2DMultisampleEXT = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXT>(gapic::GetGfxProcAddress("glFramebufferTexture2DMultisampleEXT", false));
        glFramebufferTexture2DMultisampleIMG = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG>(gapic::GetGfxProcAddress("glFramebufferTexture2DMultisampleIMG", false));
        glFramebufferTexture3DOES = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE3DOES>(gapic::GetGfxProcAddress("glFramebufferTexture3DOES", false));
        glFramebufferTextureMultiviewOVR = reinterpret_cast<PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVR>(gapic::GetGfxProcAddress("glFramebufferTextureMultiviewOVR", false));
        glFramebufferTextureOES = reinterpret_cast<PFNGLFRAMEBUFFERTEXTUREOES>(gapic::GetGfxProcAddress("glFramebufferTextureOES", false));
        glGenFencesNV = reinterpret_cast<PFNGLGENFENCESNV>(gapic::GetGfxProcAddress("glGenFencesNV", false));
        glGenPathsNV = reinterpret_cast<PFNGLGENPATHSNV>(gapic::GetGfxProcAddress("glGenPathsNV", false));
        glGenPerfMonitorsAMD = reinterpret_cast<PFNGLGENPERFMONITORSAMD>(gapic::GetGfxProcAddress("glGenPerfMonitorsAMD", false));
        glGenProgramPipelinesEXT = reinterpret_cast<PFNGLGENPROGRAMPIPELINESEXT>(gapic::GetGfxProcAddress("glGenProgramPipelinesEXT", false));
        glGenQueriesEXT = reinterpret_cast<PFNGLGENQUERIESEXT>(gapic::GetGfxProcAddress("glGenQueriesEXT", false));
        glGenVertexArraysOES = reinterpret_cast<PFNGLGENVERTEXARRAYSOES>(gapic::GetGfxProcAddress("glGenVertexArraysOES", false));
        glGetBufferPointervOES = reinterpret_cast<PFNGLGETBUFFERPOINTERVOES>(gapic::GetGfxProcAddress("glGetBufferPointervOES", false));
        glGetCoverageModulationTableNV = reinterpret_cast<PFNGLGETCOVERAGEMODULATIONTABLENV>(gapic::GetGfxProcAddress("glGetCoverageModulationTableNV", false));
        glGetDriverControlStringQCOM = reinterpret_cast<PFNGLGETDRIVERCONTROLSTRINGQCOM>(gapic::GetGfxProcAddress("glGetDriverControlStringQCOM", false));
        glGetDriverControlsQCOM = reinterpret_cast<PFNGLGETDRIVERCONTROLSQCOM>(gapic::GetGfxProcAddress("glGetDriverControlsQCOM", false));
        glGetFenceivNV = reinterpret_cast<PFNGLGETFENCEIVNV>(gapic::GetGfxProcAddress("glGetFenceivNV", false));
        glGetFirstPerfQueryIdINTEL = reinterpret_cast<PFNGLGETFIRSTPERFQUERYIDINTEL>(gapic::GetGfxProcAddress("glGetFirstPerfQueryIdINTEL", false));
        glGetFloati_vNV = reinterpret_cast<PFNGLGETFLOATI_VNV>(gapic::GetGfxProcAddress("glGetFloati_vNV", false));
        glGetFragDataIndexEXT = reinterpret_cast<PFNGLGETFRAGDATAINDEXEXT>(gapic::GetGfxProcAddress("glGetFragDataIndexEXT", false));
        glGetGraphicsResetStatusEXT = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXT>(gapic::GetGfxProcAddress("glGetGraphicsResetStatusEXT", false));
        glGetGraphicsResetStatusKHR = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSKHR>(gapic::GetGfxProcAddress("glGetGraphicsResetStatusKHR", false));
        glGetImageHandleNV = reinterpret_cast<PFNGLGETIMAGEHANDLENV>(gapic::GetGfxProcAddress("glGetImageHandleNV", false));
        glGetInteger64vAPPLE = reinterpret_cast<PFNGLGETINTEGER64VAPPLE>(gapic::GetGfxProcAddress("glGetInteger64vAPPLE", false));
        glGetIntegeri_vEXT = reinterpret_cast<PFNGLGETINTEGERI_VEXT>(gapic::GetGfxProcAddress("glGetIntegeri_vEXT", false));
        glGetInternalformatSampleivNV = reinterpret_cast<PFNGLGETINTERNALFORMATSAMPLEIVNV>(gapic::GetGfxProcAddress("glGetInternalformatSampleivNV", false));
        glGetNextPerfQueryIdINTEL = reinterpret_cast<PFNGLGETNEXTPERFQUERYIDINTEL>(gapic::GetGfxProcAddress("glGetNextPerfQueryIdINTEL", false));
        glGetObjectLabelEXT = reinterpret_cast<PFNGLGETOBJECTLABELEXT>(gapic::GetGfxProcAddress("glGetObjectLabelEXT", false));
        glGetPathCommandsNV = reinterpret_cast<PFNGLGETPATHCOMMANDSNV>(gapic::GetGfxProcAddress("glGetPathCommandsNV", false));
        glGetPathCoordsNV = reinterpret_cast<PFNGLGETPATHCOORDSNV>(gapic::GetGfxProcAddress("glGetPathCoordsNV", false));
        glGetPathDashArrayNV = reinterpret_cast<PFNGLGETPATHDASHARRAYNV>(gapic::GetGfxProcAddress("glGetPathDashArrayNV", false));
        glGetPathLengthNV = reinterpret_cast<PFNGLGETPATHLENGTHNV>(gapic::GetGfxProcAddress("glGetPathLengthNV", false));
        glGetPathMetricRangeNV = reinterpret_cast<PFNGLGETPATHMETRICRANGENV>(gapic::GetGfxProcAddress("glGetPathMetricRangeNV", false));
        glGetPathMetricsNV = reinterpret_cast<PFNGLGETPATHMETRICSNV>(gapic::GetGfxProcAddress("glGetPathMetricsNV", false));
        glGetPathParameterfvNV = reinterpret_cast<PFNGLGETPATHPARAMETERFVNV>(gapic::GetGfxProcAddress("glGetPathParameterfvNV", false));
        glGetPathParameterivNV = reinterpret_cast<PFNGLGETPATHPARAMETERIVNV>(gapic::GetGfxProcAddress("glGetPathParameterivNV", false));
        glGetPathSpacingNV = reinterpret_cast<PFNGLGETPATHSPACINGNV>(gapic::GetGfxProcAddress("glGetPathSpacingNV", false));
        glGetPerfCounterInfoINTEL = reinterpret_cast<PFNGLGETPERFCOUNTERINFOINTEL>(gapic::GetGfxProcAddress("glGetPerfCounterInfoINTEL", false));
        glGetPerfMonitorCounterDataAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERDATAAMD>(gapic::GetGfxProcAddress("glGetPerfMonitorCounterDataAMD", false));
        glGetPerfMonitorCounterInfoAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERINFOAMD>(gapic::GetGfxProcAddress("glGetPerfMonitorCounterInfoAMD", false));
        glGetPerfMonitorCounterStringAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERSTRINGAMD>(gapic::GetGfxProcAddress("glGetPerfMonitorCounterStringAMD", false));
        glGetPerfMonitorCountersAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERSAMD>(gapic::GetGfxProcAddress("glGetPerfMonitorCountersAMD", false));
        glGetPerfMonitorGroupStringAMD = reinterpret_cast<PFNGLGETPERFMONITORGROUPSTRINGAMD>(gapic::GetGfxProcAddress("glGetPerfMonitorGroupStringAMD", false));
        glGetPerfMonitorGroupsAMD = reinterpret_cast<PFNGLGETPERFMONITORGROUPSAMD>(gapic::GetGfxProcAddress("glGetPerfMonitorGroupsAMD", false));
        glGetPerfQueryDataINTEL = reinterpret_cast<PFNGLGETPERFQUERYDATAINTEL>(gapic::GetGfxProcAddress("glGetPerfQueryDataINTEL", false));
        glGetPerfQueryIdByNameINTEL = reinterpret_cast<PFNGLGETPERFQUERYIDBYNAMEINTEL>(gapic::GetGfxProcAddress("glGetPerfQueryIdByNameINTEL", false));
        glGetPerfQueryInfoINTEL = reinterpret_cast<PFNGLGETPERFQUERYINFOINTEL>(gapic::GetGfxProcAddress("glGetPerfQueryInfoINTEL", false));
        glGetProgramBinaryOES = reinterpret_cast<PFNGLGETPROGRAMBINARYOES>(gapic::GetGfxProcAddress("glGetProgramBinaryOES", false));
        glGetProgramPipelineInfoLogEXT = reinterpret_cast<PFNGLGETPROGRAMPIPELINEINFOLOGEXT>(gapic::GetGfxProcAddress("glGetProgramPipelineInfoLogEXT", false));
        glGetProgramPipelineivEXT = reinterpret_cast<PFNGLGETPROGRAMPIPELINEIVEXT>(gapic::GetGfxProcAddress("glGetProgramPipelineivEXT", false));
        glGetProgramResourceLocationIndexEXT = reinterpret_cast<PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXT>(gapic::GetGfxProcAddress("glGetProgramResourceLocationIndexEXT", false));
        glGetProgramResourcefvNV = reinterpret_cast<PFNGLGETPROGRAMRESOURCEFVNV>(gapic::GetGfxProcAddress("glGetProgramResourcefvNV", false));
        glGetQueryObjecti64vEXT = reinterpret_cast<PFNGLGETQUERYOBJECTI64VEXT>(gapic::GetGfxProcAddress("glGetQueryObjecti64vEXT", false));
        glGetQueryObjectivEXT = reinterpret_cast<PFNGLGETQUERYOBJECTIVEXT>(gapic::GetGfxProcAddress("glGetQueryObjectivEXT", false));
        glGetQueryObjectui64vEXT = reinterpret_cast<PFNGLGETQUERYOBJECTUI64VEXT>(gapic::GetGfxProcAddress("glGetQueryObjectui64vEXT", false));
        glGetQueryObjectuivEXT = reinterpret_cast<PFNGLGETQUERYOBJECTUIVEXT>(gapic::GetGfxProcAddress("glGetQueryObjectuivEXT", false));
        glGetQueryivEXT = reinterpret_cast<PFNGLGETQUERYIVEXT>(gapic::GetGfxProcAddress("glGetQueryivEXT", false));
        glGetSamplerParameterIivOES = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIIVOES>(gapic::GetGfxProcAddress("glGetSamplerParameterIivOES", false));
        glGetSamplerParameterIuivOES = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIUIVOES>(gapic::GetGfxProcAddress("glGetSamplerParameterIuivOES", false));
        glGetSyncivAPPLE = reinterpret_cast<PFNGLGETSYNCIVAPPLE>(gapic::GetGfxProcAddress("glGetSyncivAPPLE", false));
        glGetTexParameterIivOES = reinterpret_cast<PFNGLGETTEXPARAMETERIIVOES>(gapic::GetGfxProcAddress("glGetTexParameterIivOES", false));
        glGetTexParameterIuivOES = reinterpret_cast<PFNGLGETTEXPARAMETERIUIVOES>(gapic::GetGfxProcAddress("glGetTexParameterIuivOES", false));
        glGetTextureHandleNV = reinterpret_cast<PFNGLGETTEXTUREHANDLENV>(gapic::GetGfxProcAddress("glGetTextureHandleNV", false));
        glGetTextureSamplerHandleNV = reinterpret_cast<PFNGLGETTEXTURESAMPLERHANDLENV>(gapic::GetGfxProcAddress("glGetTextureSamplerHandleNV", false));
        glGetTranslatedShaderSourceANGLE = reinterpret_cast<PFNGLGETTRANSLATEDSHADERSOURCEANGLE>(gapic::GetGfxProcAddress("glGetTranslatedShaderSourceANGLE", false));
        glGetnUniformfvEXT = reinterpret_cast<PFNGLGETNUNIFORMFVEXT>(gapic::GetGfxProcAddress("glGetnUniformfvEXT", false));
        glGetnUniformfvKHR = reinterpret_cast<PFNGLGETNUNIFORMFVKHR>(gapic::GetGfxProcAddress("glGetnUniformfvKHR", false));
        glGetnUniformivEXT = reinterpret_cast<PFNGLGETNUNIFORMIVEXT>(gapic::GetGfxProcAddress("glGetnUniformivEXT", false));
        glGetnUniformivKHR = reinterpret_cast<PFNGLGETNUNIFORMIVKHR>(gapic::GetGfxProcAddress("glGetnUniformivKHR", false));
        glGetnUniformuivKHR = reinterpret_cast<PFNGLGETNUNIFORMUIVKHR>(gapic::GetGfxProcAddress("glGetnUniformuivKHR", false));
        glInsertEventMarkerEXT = reinterpret_cast<PFNGLINSERTEVENTMARKEREXT>(gapic::GetGfxProcAddress("glInsertEventMarkerEXT", false));
        glInterpolatePathsNV = reinterpret_cast<PFNGLINTERPOLATEPATHSNV>(gapic::GetGfxProcAddress("glInterpolatePathsNV", false));
        glIsEnablediNV = reinterpret_cast<PFNGLISENABLEDINV>(gapic::GetGfxProcAddress("glIsEnablediNV", false));
        glIsEnablediOES = reinterpret_cast<PFNGLISENABLEDIOES>(gapic::GetGfxProcAddress("glIsEnablediOES", false));
        glIsFenceNV = reinterpret_cast<PFNGLISFENCENV>(gapic::GetGfxProcAddress("glIsFenceNV", false));
        glIsImageHandleResidentNV = reinterpret_cast<PFNGLISIMAGEHANDLERESIDENTNV>(gapic::GetGfxProcAddress("glIsImageHandleResidentNV", false));
        glIsPathNV = reinterpret_cast<PFNGLISPATHNV>(gapic::GetGfxProcAddress("glIsPathNV", false));
        glIsPointInFillPathNV = reinterpret_cast<PFNGLISPOINTINFILLPATHNV>(gapic::GetGfxProcAddress("glIsPointInFillPathNV", false));
        glIsPointInStrokePathNV = reinterpret_cast<PFNGLISPOINTINSTROKEPATHNV>(gapic::GetGfxProcAddress("glIsPointInStrokePathNV", false));
        glIsProgramPipelineEXT = reinterpret_cast<PFNGLISPROGRAMPIPELINEEXT>(gapic::GetGfxProcAddress("glIsProgramPipelineEXT", false));
        glIsQueryEXT = reinterpret_cast<PFNGLISQUERYEXT>(gapic::GetGfxProcAddress("glIsQueryEXT", false));
        glIsSyncAPPLE = reinterpret_cast<PFNGLISSYNCAPPLE>(gapic::GetGfxProcAddress("glIsSyncAPPLE", false));
        glIsTextureHandleResidentNV = reinterpret_cast<PFNGLISTEXTUREHANDLERESIDENTNV>(gapic::GetGfxProcAddress("glIsTextureHandleResidentNV", false));
        glIsVertexArrayOES = reinterpret_cast<PFNGLISVERTEXARRAYOES>(gapic::GetGfxProcAddress("glIsVertexArrayOES", false));
        glLabelObjectEXT = reinterpret_cast<PFNGLLABELOBJECTEXT>(gapic::GetGfxProcAddress("glLabelObjectEXT", false));
        glMakeImageHandleNonResidentNV = reinterpret_cast<PFNGLMAKEIMAGEHANDLENONRESIDENTNV>(gapic::GetGfxProcAddress("glMakeImageHandleNonResidentNV", false));
        glMakeImageHandleResidentNV = reinterpret_cast<PFNGLMAKEIMAGEHANDLERESIDENTNV>(gapic::GetGfxProcAddress("glMakeImageHandleResidentNV", false));
        glMakeTextureHandleNonResidentNV = reinterpret_cast<PFNGLMAKETEXTUREHANDLENONRESIDENTNV>(gapic::GetGfxProcAddress("glMakeTextureHandleNonResidentNV", false));
        glMakeTextureHandleResidentNV = reinterpret_cast<PFNGLMAKETEXTUREHANDLERESIDENTNV>(gapic::GetGfxProcAddress("glMakeTextureHandleResidentNV", false));
        glMapBufferOES = reinterpret_cast<PFNGLMAPBUFFEROES>(gapic::GetGfxProcAddress("glMapBufferOES", false));
        glMapBufferRangeEXT = reinterpret_cast<PFNGLMAPBUFFERRANGEEXT>(gapic::GetGfxProcAddress("glMapBufferRangeEXT", false));
        glMatrixLoad3x2fNV = reinterpret_cast<PFNGLMATRIXLOAD3X2FNV>(gapic::GetGfxProcAddress("glMatrixLoad3x2fNV", false));
        glMatrixLoad3x3fNV = reinterpret_cast<PFNGLMATRIXLOAD3X3FNV>(gapic::GetGfxProcAddress("glMatrixLoad3x3fNV", false));
        glMatrixLoadTranspose3x3fNV = reinterpret_cast<PFNGLMATRIXLOADTRANSPOSE3X3FNV>(gapic::GetGfxProcAddress("glMatrixLoadTranspose3x3fNV", false));
        glMatrixMult3x2fNV = reinterpret_cast<PFNGLMATRIXMULT3X2FNV>(gapic::GetGfxProcAddress("glMatrixMult3x2fNV", false));
        glMatrixMult3x3fNV = reinterpret_cast<PFNGLMATRIXMULT3X3FNV>(gapic::GetGfxProcAddress("glMatrixMult3x3fNV", false));
        glMatrixMultTranspose3x3fNV = reinterpret_cast<PFNGLMATRIXMULTTRANSPOSE3X3FNV>(gapic::GetGfxProcAddress("glMatrixMultTranspose3x3fNV", false));
        glMultiDrawArraysEXT = reinterpret_cast<PFNGLMULTIDRAWARRAYSEXT>(gapic::GetGfxProcAddress("glMultiDrawArraysEXT", false));
        glMultiDrawArraysIndirectEXT = reinterpret_cast<PFNGLMULTIDRAWARRAYSINDIRECTEXT>(gapic::GetGfxProcAddress("glMultiDrawArraysIndirectEXT", false));
        glMultiDrawElementsBaseVertexEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSBASEVERTEXEXT>(gapic::GetGfxProcAddress("glMultiDrawElementsBaseVertexEXT", false));
        glMultiDrawElementsBaseVertexOES = reinterpret_cast<PFNGLMULTIDRAWELEMENTSBASEVERTEXOES>(gapic::GetGfxProcAddress("glMultiDrawElementsBaseVertexOES", false));
        glMultiDrawElementsEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSEXT>(gapic::GetGfxProcAddress("glMultiDrawElementsEXT", false));
        glMultiDrawElementsIndirectEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSINDIRECTEXT>(gapic::GetGfxProcAddress("glMultiDrawElementsIndirectEXT", false));
        glNamedFramebufferSampleLocationsfvNV = reinterpret_cast<PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV>(gapic::GetGfxProcAddress("glNamedFramebufferSampleLocationsfvNV", false));
        glPatchParameteriOES = reinterpret_cast<PFNGLPATCHPARAMETERIOES>(gapic::GetGfxProcAddress("glPatchParameteriOES", false));
        glPathCommandsNV = reinterpret_cast<PFNGLPATHCOMMANDSNV>(gapic::GetGfxProcAddress("glPathCommandsNV", false));
        glPathCoordsNV = reinterpret_cast<PFNGLPATHCOORDSNV>(gapic::GetGfxProcAddress("glPathCoordsNV", false));
        glPathCoverDepthFuncNV = reinterpret_cast<PFNGLPATHCOVERDEPTHFUNCNV>(gapic::GetGfxProcAddress("glPathCoverDepthFuncNV", false));
        glPathDashArrayNV = reinterpret_cast<PFNGLPATHDASHARRAYNV>(gapic::GetGfxProcAddress("glPathDashArrayNV", false));
        glPathGlyphIndexArrayNV = reinterpret_cast<PFNGLPATHGLYPHINDEXARRAYNV>(gapic::GetGfxProcAddress("glPathGlyphIndexArrayNV", false));
        glPathGlyphIndexRangeNV = reinterpret_cast<PFNGLPATHGLYPHINDEXRANGENV>(gapic::GetGfxProcAddress("glPathGlyphIndexRangeNV", false));
        glPathGlyphRangeNV = reinterpret_cast<PFNGLPATHGLYPHRANGENV>(gapic::GetGfxProcAddress("glPathGlyphRangeNV", false));
        glPathGlyphsNV = reinterpret_cast<PFNGLPATHGLYPHSNV>(gapic::GetGfxProcAddress("glPathGlyphsNV", false));
        glPathMemoryGlyphIndexArrayNV = reinterpret_cast<PFNGLPATHMEMORYGLYPHINDEXARRAYNV>(gapic::GetGfxProcAddress("glPathMemoryGlyphIndexArrayNV", false));
        glPathParameterfNV = reinterpret_cast<PFNGLPATHPARAMETERFNV>(gapic::GetGfxProcAddress("glPathParameterfNV", false));
        glPathParameterfvNV = reinterpret_cast<PFNGLPATHPARAMETERFVNV>(gapic::GetGfxProcAddress("glPathParameterfvNV", false));
        glPathParameteriNV = reinterpret_cast<PFNGLPATHPARAMETERINV>(gapic::GetGfxProcAddress("glPathParameteriNV", false));
        glPathParameterivNV = reinterpret_cast<PFNGLPATHPARAMETERIVNV>(gapic::GetGfxProcAddress("glPathParameterivNV", false));
        glPathStencilDepthOffsetNV = reinterpret_cast<PFNGLPATHSTENCILDEPTHOFFSETNV>(gapic::GetGfxProcAddress("glPathStencilDepthOffsetNV", false));
        glPathStencilFuncNV = reinterpret_cast<PFNGLPATHSTENCILFUNCNV>(gapic::GetGfxProcAddress("glPathStencilFuncNV", false));
        glPathStringNV = reinterpret_cast<PFNGLPATHSTRINGNV>(gapic::GetGfxProcAddress("glPathStringNV", false));
        glPathSubCommandsNV = reinterpret_cast<PFNGLPATHSUBCOMMANDSNV>(gapic::GetGfxProcAddress("glPathSubCommandsNV", false));
        glPathSubCoordsNV = reinterpret_cast<PFNGLPATHSUBCOORDSNV>(gapic::GetGfxProcAddress("glPathSubCoordsNV", false));
        glPointAlongPathNV = reinterpret_cast<PFNGLPOINTALONGPATHNV>(gapic::GetGfxProcAddress("glPointAlongPathNV", false));
        glPolygonModeNV = reinterpret_cast<PFNGLPOLYGONMODENV>(gapic::GetGfxProcAddress("glPolygonModeNV", false));
        glPopGroupMarkerEXT = reinterpret_cast<PFNGLPOPGROUPMARKEREXT>(gapic::GetGfxProcAddress("glPopGroupMarkerEXT", false));
        glPrimitiveBoundingBoxOES = reinterpret_cast<PFNGLPRIMITIVEBOUNDINGBOXOES>(gapic::GetGfxProcAddress("glPrimitiveBoundingBoxOES", false));
        glProgramBinaryOES = reinterpret_cast<PFNGLPROGRAMBINARYOES>(gapic::GetGfxProcAddress("glProgramBinaryOES", false));
        glProgramParameteriEXT = reinterpret_cast<PFNGLPROGRAMPARAMETERIEXT>(gapic::GetGfxProcAddress("glProgramParameteriEXT", false));
        glProgramPathFragmentInputGenNV = reinterpret_cast<PFNGLPROGRAMPATHFRAGMENTINPUTGENNV>(gapic::GetGfxProcAddress("glProgramPathFragmentInputGenNV", false));
        glProgramUniform1fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1FEXT>(gapic::GetGfxProcAddress("glProgramUniform1fEXT", false));
        glProgramUniform1fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1FVEXT>(gapic::GetGfxProcAddress("glProgramUniform1fvEXT", false));
        glProgramUniform1iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1IEXT>(gapic::GetGfxProcAddress("glProgramUniform1iEXT", false));
        glProgramUniform1ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1IVEXT>(gapic::GetGfxProcAddress("glProgramUniform1ivEXT", false));
        glProgramUniform1uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1UIEXT>(gapic::GetGfxProcAddress("glProgramUniform1uiEXT", false));
        glProgramUniform1uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1UIVEXT>(gapic::GetGfxProcAddress("glProgramUniform1uivEXT", false));
        glProgramUniform2fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2FEXT>(gapic::GetGfxProcAddress("glProgramUniform2fEXT", false));
        glProgramUniform2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2FVEXT>(gapic::GetGfxProcAddress("glProgramUniform2fvEXT", false));
        glProgramUniform2iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2IEXT>(gapic::GetGfxProcAddress("glProgramUniform2iEXT", false));
        glProgramUniform2ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2IVEXT>(gapic::GetGfxProcAddress("glProgramUniform2ivEXT", false));
        glProgramUniform2uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2UIEXT>(gapic::GetGfxProcAddress("glProgramUniform2uiEXT", false));
        glProgramUniform2uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2UIVEXT>(gapic::GetGfxProcAddress("glProgramUniform2uivEXT", false));
        glProgramUniform3fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3FEXT>(gapic::GetGfxProcAddress("glProgramUniform3fEXT", false));
        glProgramUniform3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3FVEXT>(gapic::GetGfxProcAddress("glProgramUniform3fvEXT", false));
        glProgramUniform3iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3IEXT>(gapic::GetGfxProcAddress("glProgramUniform3iEXT", false));
        glProgramUniform3ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3IVEXT>(gapic::GetGfxProcAddress("glProgramUniform3ivEXT", false));
        glProgramUniform3uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3UIEXT>(gapic::GetGfxProcAddress("glProgramUniform3uiEXT", false));
        glProgramUniform3uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3UIVEXT>(gapic::GetGfxProcAddress("glProgramUniform3uivEXT", false));
        glProgramUniform4fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4FEXT>(gapic::GetGfxProcAddress("glProgramUniform4fEXT", false));
        glProgramUniform4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4FVEXT>(gapic::GetGfxProcAddress("glProgramUniform4fvEXT", false));
        glProgramUniform4iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4IEXT>(gapic::GetGfxProcAddress("glProgramUniform4iEXT", false));
        glProgramUniform4ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4IVEXT>(gapic::GetGfxProcAddress("glProgramUniform4ivEXT", false));
        glProgramUniform4uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4UIEXT>(gapic::GetGfxProcAddress("glProgramUniform4uiEXT", false));
        glProgramUniform4uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4UIVEXT>(gapic::GetGfxProcAddress("glProgramUniform4uivEXT", false));
        glProgramUniformHandleui64NV = reinterpret_cast<PFNGLPROGRAMUNIFORMHANDLEUI64NV>(gapic::GetGfxProcAddress("glProgramUniformHandleui64NV", false));
        glProgramUniformHandleui64vNV = reinterpret_cast<PFNGLPROGRAMUNIFORMHANDLEUI64VNV>(gapic::GetGfxProcAddress("glProgramUniformHandleui64vNV", false));
        glProgramUniformMatrix2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix2fvEXT", false));
        glProgramUniformMatrix2x3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X3FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix2x3fvEXT", false));
        glProgramUniformMatrix2x4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X4FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix2x4fvEXT", false));
        glProgramUniformMatrix3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix3fvEXT", false));
        glProgramUniformMatrix3x2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X2FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix3x2fvEXT", false));
        glProgramUniformMatrix3x4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X4FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix3x4fvEXT", false));
        glProgramUniformMatrix4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix4fvEXT", false));
        glProgramUniformMatrix4x2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X2FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix4x2fvEXT", false));
        glProgramUniformMatrix4x3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X3FVEXT>(gapic::GetGfxProcAddress("glProgramUniformMatrix4x3fvEXT", false));
        glPushGroupMarkerEXT = reinterpret_cast<PFNGLPUSHGROUPMARKEREXT>(gapic::GetGfxProcAddress("glPushGroupMarkerEXT", false));
        glQueryCounterEXT = reinterpret_cast<PFNGLQUERYCOUNTEREXT>(gapic::GetGfxProcAddress("glQueryCounterEXT", false));
        glRasterSamplesEXT = reinterpret_cast<PFNGLRASTERSAMPLESEXT>(gapic::GetGfxProcAddress("glRasterSamplesEXT", false));
        glReadBufferIndexedEXT = reinterpret_cast<PFNGLREADBUFFERINDEXEDEXT>(gapic::GetGfxProcAddress("glReadBufferIndexedEXT", false));
        glReadBufferNV = reinterpret_cast<PFNGLREADBUFFERNV>(gapic::GetGfxProcAddress("glReadBufferNV", false));
        glReadnPixelsEXT = reinterpret_cast<PFNGLREADNPIXELSEXT>(gapic::GetGfxProcAddress("glReadnPixelsEXT", false));
        glReadnPixelsKHR = reinterpret_cast<PFNGLREADNPIXELSKHR>(gapic::GetGfxProcAddress("glReadnPixelsKHR", false));
        glRenderbufferStorageMultisampleANGLE = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLE>(gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleANGLE", false));
        glRenderbufferStorageMultisampleAPPLE = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLE>(gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleAPPLE", false));
        glRenderbufferStorageMultisampleEXT = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXT>(gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleEXT", false));
        glRenderbufferStorageMultisampleIMG = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG>(gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleIMG", false));
        glRenderbufferStorageMultisampleNV = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLENV>(gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleNV", false));
        glResolveDepthValuesNV = reinterpret_cast<PFNGLRESOLVEDEPTHVALUESNV>(gapic::GetGfxProcAddress("glResolveDepthValuesNV", false));
        glResolveMultisampleFramebufferAPPLE = reinterpret_cast<PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLE>(gapic::GetGfxProcAddress("glResolveMultisampleFramebufferAPPLE", false));
        glSamplerParameterIivOES = reinterpret_cast<PFNGLSAMPLERPARAMETERIIVOES>(gapic::GetGfxProcAddress("glSamplerParameterIivOES", false));
        glSamplerParameterIuivOES = reinterpret_cast<PFNGLSAMPLERPARAMETERIUIVOES>(gapic::GetGfxProcAddress("glSamplerParameterIuivOES", false));
        glScissorArrayvNV = reinterpret_cast<PFNGLSCISSORARRAYVNV>(gapic::GetGfxProcAddress("glScissorArrayvNV", false));
        glScissorIndexedNV = reinterpret_cast<PFNGLSCISSORINDEXEDNV>(gapic::GetGfxProcAddress("glScissorIndexedNV", false));
        glScissorIndexedvNV = reinterpret_cast<PFNGLSCISSORINDEXEDVNV>(gapic::GetGfxProcAddress("glScissorIndexedvNV", false));
        glSelectPerfMonitorCountersAMD = reinterpret_cast<PFNGLSELECTPERFMONITORCOUNTERSAMD>(gapic::GetGfxProcAddress("glSelectPerfMonitorCountersAMD", false));
        glSetFenceNV = reinterpret_cast<PFNGLSETFENCENV>(gapic::GetGfxProcAddress("glSetFenceNV", false));
        glStartTilingQCOM = reinterpret_cast<PFNGLSTARTTILINGQCOM>(gapic::GetGfxProcAddress("glStartTilingQCOM", false));
        glStencilFillPathInstancedNV = reinterpret_cast<PFNGLSTENCILFILLPATHINSTANCEDNV>(gapic::GetGfxProcAddress("glStencilFillPathInstancedNV", false));
        glStencilFillPathNV = reinterpret_cast<PFNGLSTENCILFILLPATHNV>(gapic::GetGfxProcAddress("glStencilFillPathNV", false));
        glStencilStrokePathInstancedNV = reinterpret_cast<PFNGLSTENCILSTROKEPATHINSTANCEDNV>(gapic::GetGfxProcAddress("glStencilStrokePathInstancedNV", false));
        glStencilStrokePathNV = reinterpret_cast<PFNGLSTENCILSTROKEPATHNV>(gapic::GetGfxProcAddress("glStencilStrokePathNV", false));
        glStencilThenCoverFillPathInstancedNV = reinterpret_cast<PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNV>(gapic::GetGfxProcAddress("glStencilThenCoverFillPathInstancedNV", false));
        glStencilThenCoverFillPathNV = reinterpret_cast<PFNGLSTENCILTHENCOVERFILLPATHNV>(gapic::GetGfxProcAddress("glStencilThenCoverFillPathNV", false));
        glStencilThenCoverStrokePathInstancedNV = reinterpret_cast<PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNV>(gapic::GetGfxProcAddress("glStencilThenCoverStrokePathInstancedNV", false));
        glStencilThenCoverStrokePathNV = reinterpret_cast<PFNGLSTENCILTHENCOVERSTROKEPATHNV>(gapic::GetGfxProcAddress("glStencilThenCoverStrokePathNV", false));
        glSubpixelPrecisionBiasNV = reinterpret_cast<PFNGLSUBPIXELPRECISIONBIASNV>(gapic::GetGfxProcAddress("glSubpixelPrecisionBiasNV", false));
        glTestFenceNV = reinterpret_cast<PFNGLTESTFENCENV>(gapic::GetGfxProcAddress("glTestFenceNV", false));
        glTexBufferOES = reinterpret_cast<PFNGLTEXBUFFEROES>(gapic::GetGfxProcAddress("glTexBufferOES", false));
        glTexBufferRangeOES = reinterpret_cast<PFNGLTEXBUFFERRANGEOES>(gapic::GetGfxProcAddress("glTexBufferRangeOES", false));
        glTexImage3DOES = reinterpret_cast<PFNGLTEXIMAGE3DOES>(gapic::GetGfxProcAddress("glTexImage3DOES", false));
        glTexPageCommitmentEXT = reinterpret_cast<PFNGLTEXPAGECOMMITMENTEXT>(gapic::GetGfxProcAddress("glTexPageCommitmentEXT", false));
        glTexParameterIivOES = reinterpret_cast<PFNGLTEXPARAMETERIIVOES>(gapic::GetGfxProcAddress("glTexParameterIivOES", false));
        glTexParameterIuivOES = reinterpret_cast<PFNGLTEXPARAMETERIUIVOES>(gapic::GetGfxProcAddress("glTexParameterIuivOES", false));
        glTexStorage1DEXT = reinterpret_cast<PFNGLTEXSTORAGE1DEXT>(gapic::GetGfxProcAddress("glTexStorage1DEXT", false));
        glTexStorage2DEXT = reinterpret_cast<PFNGLTEXSTORAGE2DEXT>(gapic::GetGfxProcAddress("glTexStorage2DEXT", false));
        glTexStorage3DEXT = reinterpret_cast<PFNGLTEXSTORAGE3DEXT>(gapic::GetGfxProcAddress("glTexStorage3DEXT", false));
        glTexSubImage3DOES = reinterpret_cast<PFNGLTEXSUBIMAGE3DOES>(gapic::GetGfxProcAddress("glTexSubImage3DOES", false));
        glTextureStorage1DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE1DEXT>(gapic::GetGfxProcAddress("glTextureStorage1DEXT", false));
        glTextureStorage2DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE2DEXT>(gapic::GetGfxProcAddress("glTextureStorage2DEXT", false));
        glTextureStorage3DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE3DEXT>(gapic::GetGfxProcAddress("glTextureStorage3DEXT", false));
        glTextureViewEXT = reinterpret_cast<PFNGLTEXTUREVIEWEXT>(gapic::GetGfxProcAddress("glTextureViewEXT", false));
        glTextureViewOES = reinterpret_cast<PFNGLTEXTUREVIEWOES>(gapic::GetGfxProcAddress("glTextureViewOES", false));
        glTransformPathNV = reinterpret_cast<PFNGLTRANSFORMPATHNV>(gapic::GetGfxProcAddress("glTransformPathNV", false));
        glUniformHandleui64NV = reinterpret_cast<PFNGLUNIFORMHANDLEUI64NV>(gapic::GetGfxProcAddress("glUniformHandleui64NV", false));
        glUniformHandleui64vNV = reinterpret_cast<PFNGLUNIFORMHANDLEUI64VNV>(gapic::GetGfxProcAddress("glUniformHandleui64vNV", false));
        glUniformMatrix2x3fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX2X3FVNV>(gapic::GetGfxProcAddress("glUniformMatrix2x3fvNV", false));
        glUniformMatrix2x4fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX2X4FVNV>(gapic::GetGfxProcAddress("glUniformMatrix2x4fvNV", false));
        glUniformMatrix3x2fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX3X2FVNV>(gapic::GetGfxProcAddress("glUniformMatrix3x2fvNV", false));
        glUniformMatrix3x4fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX3X4FVNV>(gapic::GetGfxProcAddress("glUniformMatrix3x4fvNV", false));
        glUniformMatrix4x2fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX4X2FVNV>(gapic::GetGfxProcAddress("glUniformMatrix4x2fvNV", false));
        glUniformMatrix4x3fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX4X3FVNV>(gapic::GetGfxProcAddress("glUniformMatrix4x3fvNV", false));
        glUnmapBufferOES = reinterpret_cast<PFNGLUNMAPBUFFEROES>(gapic::GetGfxProcAddress("glUnmapBufferOES", false));
        glUseProgramStagesEXT = reinterpret_cast<PFNGLUSEPROGRAMSTAGESEXT>(gapic::GetGfxProcAddress("glUseProgramStagesEXT", false));
        glValidateProgramPipelineEXT = reinterpret_cast<PFNGLVALIDATEPROGRAMPIPELINEEXT>(gapic::GetGfxProcAddress("glValidateProgramPipelineEXT", false));
        glVertexAttribDivisorANGLE = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORANGLE>(gapic::GetGfxProcAddress("glVertexAttribDivisorANGLE", false));
        glVertexAttribDivisorEXT = reinterpret_cast<PFNGLVERTEXATTRIBDIVISOREXT>(gapic::GetGfxProcAddress("glVertexAttribDivisorEXT", false));
        glVertexAttribDivisorNV = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORNV>(gapic::GetGfxProcAddress("glVertexAttribDivisorNV", false));
        glViewportArrayvNV = reinterpret_cast<PFNGLVIEWPORTARRAYVNV>(gapic::GetGfxProcAddress("glViewportArrayvNV", false));
        glViewportIndexedfNV = reinterpret_cast<PFNGLVIEWPORTINDEXEDFNV>(gapic::GetGfxProcAddress("glViewportIndexedfNV", false));
        glViewportIndexedfvNV = reinterpret_cast<PFNGLVIEWPORTINDEXEDFVNV>(gapic::GetGfxProcAddress("glViewportIndexedfvNV", false));
        glWaitSyncAPPLE = reinterpret_cast<PFNGLWAITSYNCAPPLE>(gapic::GetGfxProcAddress("glWaitSyncAPPLE", false));
        glWeightPathsNV = reinterpret_cast<PFNGLWEIGHTPATHSNV>(gapic::GetGfxProcAddress("glWeightPathsNV", false));
        glBlendBarrier = reinterpret_cast<PFNGLBLENDBARRIER>(gapic::GetGfxProcAddress("glBlendBarrier", false));
        glBlendColor = reinterpret_cast<PFNGLBLENDCOLOR>(gapic::GetGfxProcAddress("glBlendColor", false));
        glBlendEquation = reinterpret_cast<PFNGLBLENDEQUATION>(gapic::GetGfxProcAddress("glBlendEquation", false));
        glBlendEquationSeparate = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATE>(gapic::GetGfxProcAddress("glBlendEquationSeparate", false));
        glBlendEquationSeparatei = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEI>(gapic::GetGfxProcAddress("glBlendEquationSeparatei", false));
        glBlendEquationi = reinterpret_cast<PFNGLBLENDEQUATIONI>(gapic::GetGfxProcAddress("glBlendEquationi", false));
        glBlendFunc = reinterpret_cast<PFNGLBLENDFUNC>(gapic::GetGfxProcAddress("glBlendFunc", false));
        glBlendFuncSeparate = reinterpret_cast<PFNGLBLENDFUNCSEPARATE>(gapic::GetGfxProcAddress("glBlendFuncSeparate", false));
        glBlendFuncSeparatei = reinterpret_cast<PFNGLBLENDFUNCSEPARATEI>(gapic::GetGfxProcAddress("glBlendFuncSeparatei", false));
        glBlendFunci = reinterpret_cast<PFNGLBLENDFUNCI>(gapic::GetGfxProcAddress("glBlendFunci", false));
        glDepthFunc = reinterpret_cast<PFNGLDEPTHFUNC>(gapic::GetGfxProcAddress("glDepthFunc", false));
        glSampleCoverage = reinterpret_cast<PFNGLSAMPLECOVERAGE>(gapic::GetGfxProcAddress("glSampleCoverage", false));
        glSampleMaski = reinterpret_cast<PFNGLSAMPLEMASKI>(gapic::GetGfxProcAddress("glSampleMaski", false));
        glScissor = reinterpret_cast<PFNGLSCISSOR>(gapic::GetGfxProcAddress("glScissor", false));
        glStencilFunc = reinterpret_cast<PFNGLSTENCILFUNC>(gapic::GetGfxProcAddress("glStencilFunc", false));
        glStencilFuncSeparate = reinterpret_cast<PFNGLSTENCILFUNCSEPARATE>(gapic::GetGfxProcAddress("glStencilFuncSeparate", false));
        glStencilOp = reinterpret_cast<PFNGLSTENCILOP>(gapic::GetGfxProcAddress("glStencilOp", false));
        glStencilOpSeparate = reinterpret_cast<PFNGLSTENCILOPSEPARATE>(gapic::GetGfxProcAddress("glStencilOpSeparate", false));
        glBindFramebuffer = reinterpret_cast<PFNGLBINDFRAMEBUFFER>(gapic::GetGfxProcAddress("glBindFramebuffer", false));
        glBindRenderbuffer = reinterpret_cast<PFNGLBINDRENDERBUFFER>(gapic::GetGfxProcAddress("glBindRenderbuffer", false));
        glBlitFramebuffer = reinterpret_cast<PFNGLBLITFRAMEBUFFER>(gapic::GetGfxProcAddress("glBlitFramebuffer", false));
        glCheckFramebufferStatus = reinterpret_cast<PFNGLCHECKFRAMEBUFFERSTATUS>(gapic::GetGfxProcAddress("glCheckFramebufferStatus", false));
        glClear = reinterpret_cast<PFNGLCLEAR>(gapic::GetGfxProcAddress("glClear", false));
        glClearBufferfi = reinterpret_cast<PFNGLCLEARBUFFERFI>(gapic::GetGfxProcAddress("glClearBufferfi", false));
        glClearBufferfv = reinterpret_cast<PFNGLCLEARBUFFERFV>(gapic::GetGfxProcAddress("glClearBufferfv", false));
        glClearBufferiv = reinterpret_cast<PFNGLCLEARBUFFERIV>(gapic::GetGfxProcAddress("glClearBufferiv", false));
        glClearBufferuiv = reinterpret_cast<PFNGLCLEARBUFFERUIV>(gapic::GetGfxProcAddress("glClearBufferuiv", false));
        glClearColor = reinterpret_cast<PFNGLCLEARCOLOR>(gapic::GetGfxProcAddress("glClearColor", false));
        glClearDepthf = reinterpret_cast<PFNGLCLEARDEPTHF>(gapic::GetGfxProcAddress("glClearDepthf", false));
        glClearStencil = reinterpret_cast<PFNGLCLEARSTENCIL>(gapic::GetGfxProcAddress("glClearStencil", false));
        glColorMask = reinterpret_cast<PFNGLCOLORMASK>(gapic::GetGfxProcAddress("glColorMask", false));
        glColorMaski = reinterpret_cast<PFNGLCOLORMASKI>(gapic::GetGfxProcAddress("glColorMaski", false));
        glDeleteFramebuffers = reinterpret_cast<PFNGLDELETEFRAMEBUFFERS>(gapic::GetGfxProcAddress("glDeleteFramebuffers", false));
        glDeleteRenderbuffers = reinterpret_cast<PFNGLDELETERENDERBUFFERS>(gapic::GetGfxProcAddress("glDeleteRenderbuffers", false));
        glDepthMask = reinterpret_cast<PFNGLDEPTHMASK>(gapic::GetGfxProcAddress("glDepthMask", false));
        glDrawBuffers = reinterpret_cast<PFNGLDRAWBUFFERS>(gapic::GetGfxProcAddress("glDrawBuffers", false));
        glFramebufferParameteri = reinterpret_cast<PFNGLFRAMEBUFFERPARAMETERI>(gapic::GetGfxProcAddress("glFramebufferParameteri", false));
        glFramebufferRenderbuffer = reinterpret_cast<PFNGLFRAMEBUFFERRENDERBUFFER>(gapic::GetGfxProcAddress("glFramebufferRenderbuffer", false));
        glFramebufferTexture = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE>(gapic::GetGfxProcAddress("glFramebufferTexture", false));
        glFramebufferTexture2D = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2D>(gapic::GetGfxProcAddress("glFramebufferTexture2D", false));
        glFramebufferTextureLayer = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURELAYER>(gapic::GetGfxProcAddress("glFramebufferTextureLayer", false));
        glGenFramebuffers = reinterpret_cast<PFNGLGENFRAMEBUFFERS>(gapic::GetGfxProcAddress("glGenFramebuffers", false));
        glGenRenderbuffers = reinterpret_cast<PFNGLGENRENDERBUFFERS>(gapic::GetGfxProcAddress("glGenRenderbuffers", false));
        glGetFramebufferAttachmentParameteriv = reinterpret_cast<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV>(gapic::GetGfxProcAddress("glGetFramebufferAttachmentParameteriv", false));
        glGetFramebufferParameteriv = reinterpret_cast<PFNGLGETFRAMEBUFFERPARAMETERIV>(gapic::GetGfxProcAddress("glGetFramebufferParameteriv", false));
        glGetRenderbufferParameteriv = reinterpret_cast<PFNGLGETRENDERBUFFERPARAMETERIV>(gapic::GetGfxProcAddress("glGetRenderbufferParameteriv", false));
        glInvalidateFramebuffer = reinterpret_cast<PFNGLINVALIDATEFRAMEBUFFER>(gapic::GetGfxProcAddress("glInvalidateFramebuffer", false));
        glInvalidateSubFramebuffer = reinterpret_cast<PFNGLINVALIDATESUBFRAMEBUFFER>(gapic::GetGfxProcAddress("glInvalidateSubFramebuffer", false));
        glIsFramebuffer = reinterpret_cast<PFNGLISFRAMEBUFFER>(gapic::GetGfxProcAddress("glIsFramebuffer", false));
        glIsRenderbuffer = reinterpret_cast<PFNGLISRENDERBUFFER>(gapic::GetGfxProcAddress("glIsRenderbuffer", false));
        glReadBuffer = reinterpret_cast<PFNGLREADBUFFER>(gapic::GetGfxProcAddress("glReadBuffer", false));
        glReadPixels = reinterpret_cast<PFNGLREADPIXELS>(gapic::GetGfxProcAddress("glReadPixels", false));
        glReadnPixels = reinterpret_cast<PFNGLREADNPIXELS>(gapic::GetGfxProcAddress("glReadnPixels", false));
        glRenderbufferStorage = reinterpret_cast<PFNGLRENDERBUFFERSTORAGE>(gapic::GetGfxProcAddress("glRenderbufferStorage", false));
        glRenderbufferStorageMultisample = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLE>(gapic::GetGfxProcAddress("glRenderbufferStorageMultisample", false));
        glStencilMask = reinterpret_cast<PFNGLSTENCILMASK>(gapic::GetGfxProcAddress("glStencilMask", false));
        glStencilMaskSeparate = reinterpret_cast<PFNGLSTENCILMASKSEPARATE>(gapic::GetGfxProcAddress("glStencilMaskSeparate", false));
        glDisable = reinterpret_cast<PFNGLDISABLE>(gapic::GetGfxProcAddress("glDisable", false));
        glDisablei = reinterpret_cast<PFNGLDISABLEI>(gapic::GetGfxProcAddress("glDisablei", false));
        glEnable = reinterpret_cast<PFNGLENABLE>(gapic::GetGfxProcAddress("glEnable", false));
        glEnablei = reinterpret_cast<PFNGLENABLEI>(gapic::GetGfxProcAddress("glEnablei", false));
        glFinish = reinterpret_cast<PFNGLFINISH>(gapic::GetGfxProcAddress("glFinish", false));
        glFlush = reinterpret_cast<PFNGLFLUSH>(gapic::GetGfxProcAddress("glFlush", false));
        glFlushMappedBufferRange = reinterpret_cast<PFNGLFLUSHMAPPEDBUFFERRANGE>(gapic::GetGfxProcAddress("glFlushMappedBufferRange", false));
        glGetError = reinterpret_cast<PFNGLGETERROR>(gapic::GetGfxProcAddress("glGetError", false));
        glGetGraphicsResetStatus = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUS>(gapic::GetGfxProcAddress("glGetGraphicsResetStatus", false));
        glHint = reinterpret_cast<PFNGLHINT>(gapic::GetGfxProcAddress("glHint", false));
        glActiveShaderProgram = reinterpret_cast<PFNGLACTIVESHADERPROGRAM>(gapic::GetGfxProcAddress("glActiveShaderProgram", false));
        glAttachShader = reinterpret_cast<PFNGLATTACHSHADER>(gapic::GetGfxProcAddress("glAttachShader", false));
        glBindAttribLocation = reinterpret_cast<PFNGLBINDATTRIBLOCATION>(gapic::GetGfxProcAddress("glBindAttribLocation", false));
        glBindProgramPipeline = reinterpret_cast<PFNGLBINDPROGRAMPIPELINE>(gapic::GetGfxProcAddress("glBindProgramPipeline", false));
        glCompileShader = reinterpret_cast<PFNGLCOMPILESHADER>(gapic::GetGfxProcAddress("glCompileShader", false));
        glCreateProgram = reinterpret_cast<PFNGLCREATEPROGRAM>(gapic::GetGfxProcAddress("glCreateProgram", false));
        glCreateShader = reinterpret_cast<PFNGLCREATESHADER>(gapic::GetGfxProcAddress("glCreateShader", false));
        glCreateShaderProgramv = reinterpret_cast<PFNGLCREATESHADERPROGRAMV>(gapic::GetGfxProcAddress("glCreateShaderProgramv", false));
        glDeleteProgram = reinterpret_cast<PFNGLDELETEPROGRAM>(gapic::GetGfxProcAddress("glDeleteProgram", false));
        glDeleteProgramPipelines = reinterpret_cast<PFNGLDELETEPROGRAMPIPELINES>(gapic::GetGfxProcAddress("glDeleteProgramPipelines", false));
        glDeleteShader = reinterpret_cast<PFNGLDELETESHADER>(gapic::GetGfxProcAddress("glDeleteShader", false));
        glDetachShader = reinterpret_cast<PFNGLDETACHSHADER>(gapic::GetGfxProcAddress("glDetachShader", false));
        glDispatchCompute = reinterpret_cast<PFNGLDISPATCHCOMPUTE>(gapic::GetGfxProcAddress("glDispatchCompute", false));
        glDispatchComputeIndirect = reinterpret_cast<PFNGLDISPATCHCOMPUTEINDIRECT>(gapic::GetGfxProcAddress("glDispatchComputeIndirect", false));
        glGenProgramPipelines = reinterpret_cast<PFNGLGENPROGRAMPIPELINES>(gapic::GetGfxProcAddress("glGenProgramPipelines", false));
        glGetActiveAttrib = reinterpret_cast<PFNGLGETACTIVEATTRIB>(gapic::GetGfxProcAddress("glGetActiveAttrib", false));
        glGetActiveUniform = reinterpret_cast<PFNGLGETACTIVEUNIFORM>(gapic::GetGfxProcAddress("glGetActiveUniform", false));
        glGetActiveUniformBlockName = reinterpret_cast<PFNGLGETACTIVEUNIFORMBLOCKNAME>(gapic::GetGfxProcAddress("glGetActiveUniformBlockName", false));
        glGetActiveUniformBlockiv = reinterpret_cast<PFNGLGETACTIVEUNIFORMBLOCKIV>(gapic::GetGfxProcAddress("glGetActiveUniformBlockiv", false));
        glGetActiveUniformsiv = reinterpret_cast<PFNGLGETACTIVEUNIFORMSIV>(gapic::GetGfxProcAddress("glGetActiveUniformsiv", false));
        glGetAttachedShaders = reinterpret_cast<PFNGLGETATTACHEDSHADERS>(gapic::GetGfxProcAddress("glGetAttachedShaders", false));
        glGetAttribLocation = reinterpret_cast<PFNGLGETATTRIBLOCATION>(gapic::GetGfxProcAddress("glGetAttribLocation", false));
        glGetFragDataLocation = reinterpret_cast<PFNGLGETFRAGDATALOCATION>(gapic::GetGfxProcAddress("glGetFragDataLocation", false));
        glGetProgramBinary = reinterpret_cast<PFNGLGETPROGRAMBINARY>(gapic::GetGfxProcAddress("glGetProgramBinary", false));
        glGetProgramInfoLog = reinterpret_cast<PFNGLGETPROGRAMINFOLOG>(gapic::GetGfxProcAddress("glGetProgramInfoLog", false));
        glGetProgramInterfaceiv = reinterpret_cast<PFNGLGETPROGRAMINTERFACEIV>(gapic::GetGfxProcAddress("glGetProgramInterfaceiv", false));
        glGetProgramPipelineInfoLog = reinterpret_cast<PFNGLGETPROGRAMPIPELINEINFOLOG>(gapic::GetGfxProcAddress("glGetProgramPipelineInfoLog", false));
        glGetProgramPipelineiv = reinterpret_cast<PFNGLGETPROGRAMPIPELINEIV>(gapic::GetGfxProcAddress("glGetProgramPipelineiv", false));
        glGetProgramResourceIndex = reinterpret_cast<PFNGLGETPROGRAMRESOURCEINDEX>(gapic::GetGfxProcAddress("glGetProgramResourceIndex", false));
        glGetProgramResourceLocation = reinterpret_cast<PFNGLGETPROGRAMRESOURCELOCATION>(gapic::GetGfxProcAddress("glGetProgramResourceLocation", false));
        glGetProgramResourceName = reinterpret_cast<PFNGLGETPROGRAMRESOURCENAME>(gapic::GetGfxProcAddress("glGetProgramResourceName", false));
        glGetProgramResourceiv = reinterpret_cast<PFNGLGETPROGRAMRESOURCEIV>(gapic::GetGfxProcAddress("glGetProgramResourceiv", false));
        glGetProgramiv = reinterpret_cast<PFNGLGETPROGRAMIV>(gapic::GetGfxProcAddress("glGetProgramiv", false));
        glGetShaderInfoLog = reinterpret_cast<PFNGLGETSHADERINFOLOG>(gapic::GetGfxProcAddress("glGetShaderInfoLog", false));
        glGetShaderPrecisionFormat = reinterpret_cast<PFNGLGETSHADERPRECISIONFORMAT>(gapic::GetGfxProcAddress("glGetShaderPrecisionFormat", false));
        glGetShaderSource = reinterpret_cast<PFNGLGETSHADERSOURCE>(gapic::GetGfxProcAddress("glGetShaderSource", false));
        glGetShaderiv = reinterpret_cast<PFNGLGETSHADERIV>(gapic::GetGfxProcAddress("glGetShaderiv", false));
        glGetUniformBlockIndex = reinterpret_cast<PFNGLGETUNIFORMBLOCKINDEX>(gapic::GetGfxProcAddress("glGetUniformBlockIndex", false));
        glGetUniformIndices = reinterpret_cast<PFNGLGETUNIFORMINDICES>(gapic::GetGfxProcAddress("glGetUniformIndices", false));
        glGetUniformLocation = reinterpret_cast<PFNGLGETUNIFORMLOCATION>(gapic::GetGfxProcAddress("glGetUniformLocation", false));
        glGetUniformfv = reinterpret_cast<PFNGLGETUNIFORMFV>(gapic::GetGfxProcAddress("glGetUniformfv", false));
        glGetUniformiv = reinterpret_cast<PFNGLGETUNIFORMIV>(gapic::GetGfxProcAddress("glGetUniformiv", false));
        glGetUniformuiv = reinterpret_cast<PFNGLGETUNIFORMUIV>(gapic::GetGfxProcAddress("glGetUniformuiv", false));
        glGetnUniformfv = reinterpret_cast<PFNGLGETNUNIFORMFV>(gapic::GetGfxProcAddress("glGetnUniformfv", false));
        glGetnUniformiv = reinterpret_cast<PFNGLGETNUNIFORMIV>(gapic::GetGfxProcAddress("glGetnUniformiv", false));
        glGetnUniformuiv = reinterpret_cast<PFNGLGETNUNIFORMUIV>(gapic::GetGfxProcAddress("glGetnUniformuiv", false));
        glIsProgram = reinterpret_cast<PFNGLISPROGRAM>(gapic::GetGfxProcAddress("glIsProgram", false));
        glIsProgramPipeline = reinterpret_cast<PFNGLISPROGRAMPIPELINE>(gapic::GetGfxProcAddress("glIsProgramPipeline", false));
        glIsShader = reinterpret_cast<PFNGLISSHADER>(gapic::GetGfxProcAddress("glIsShader", false));
        glLinkProgram = reinterpret_cast<PFNGLLINKPROGRAM>(gapic::GetGfxProcAddress("glLinkProgram", false));
        glMemoryBarrier = reinterpret_cast<PFNGLMEMORYBARRIER>(gapic::GetGfxProcAddress("glMemoryBarrier", false));
        glMemoryBarrierByRegion = reinterpret_cast<PFNGLMEMORYBARRIERBYREGION>(gapic::GetGfxProcAddress("glMemoryBarrierByRegion", false));
        glProgramBinary = reinterpret_cast<PFNGLPROGRAMBINARY>(gapic::GetGfxProcAddress("glProgramBinary", false));
        glProgramParameteri = reinterpret_cast<PFNGLPROGRAMPARAMETERI>(gapic::GetGfxProcAddress("glProgramParameteri", false));
        glProgramUniform1f = reinterpret_cast<PFNGLPROGRAMUNIFORM1F>(gapic::GetGfxProcAddress("glProgramUniform1f", false));
        glProgramUniform1fv = reinterpret_cast<PFNGLPROGRAMUNIFORM1FV>(gapic::GetGfxProcAddress("glProgramUniform1fv", false));
        glProgramUniform1i = reinterpret_cast<PFNGLPROGRAMUNIFORM1I>(gapic::GetGfxProcAddress("glProgramUniform1i", false));
        glProgramUniform1iv = reinterpret_cast<PFNGLPROGRAMUNIFORM1IV>(gapic::GetGfxProcAddress("glProgramUniform1iv", false));
        glProgramUniform1ui = reinterpret_cast<PFNGLPROGRAMUNIFORM1UI>(gapic::GetGfxProcAddress("glProgramUniform1ui", false));
        glProgramUniform1uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM1UIV>(gapic::GetGfxProcAddress("glProgramUniform1uiv", false));
        glProgramUniform2f = reinterpret_cast<PFNGLPROGRAMUNIFORM2F>(gapic::GetGfxProcAddress("glProgramUniform2f", false));
        glProgramUniform2fv = reinterpret_cast<PFNGLPROGRAMUNIFORM2FV>(gapic::GetGfxProcAddress("glProgramUniform2fv", false));
        glProgramUniform2i = reinterpret_cast<PFNGLPROGRAMUNIFORM2I>(gapic::GetGfxProcAddress("glProgramUniform2i", false));
        glProgramUniform2iv = reinterpret_cast<PFNGLPROGRAMUNIFORM2IV>(gapic::GetGfxProcAddress("glProgramUniform2iv", false));
        glProgramUniform2ui = reinterpret_cast<PFNGLPROGRAMUNIFORM2UI>(gapic::GetGfxProcAddress("glProgramUniform2ui", false));
        glProgramUniform2uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM2UIV>(gapic::GetGfxProcAddress("glProgramUniform2uiv", false));
        glProgramUniform3f = reinterpret_cast<PFNGLPROGRAMUNIFORM3F>(gapic::GetGfxProcAddress("glProgramUniform3f", false));
        glProgramUniform3fv = reinterpret_cast<PFNGLPROGRAMUNIFORM3FV>(gapic::GetGfxProcAddress("glProgramUniform3fv", false));
        glProgramUniform3i = reinterpret_cast<PFNGLPROGRAMUNIFORM3I>(gapic::GetGfxProcAddress("glProgramUniform3i", false));
        glProgramUniform3iv = reinterpret_cast<PFNGLPROGRAMUNIFORM3IV>(gapic::GetGfxProcAddress("glProgramUniform3iv", false));
        glProgramUniform3ui = reinterpret_cast<PFNGLPROGRAMUNIFORM3UI>(gapic::GetGfxProcAddress("glProgramUniform3ui", false));
        glProgramUniform3uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM3UIV>(gapic::GetGfxProcAddress("glProgramUniform3uiv", false));
        glProgramUniform4f = reinterpret_cast<PFNGLPROGRAMUNIFORM4F>(gapic::GetGfxProcAddress("glProgramUniform4f", false));
        glProgramUniform4fv = reinterpret_cast<PFNGLPROGRAMUNIFORM4FV>(gapic::GetGfxProcAddress("glProgramUniform4fv", false));
        glProgramUniform4i = reinterpret_cast<PFNGLPROGRAMUNIFORM4I>(gapic::GetGfxProcAddress("glProgramUniform4i", false));
        glProgramUniform4iv = reinterpret_cast<PFNGLPROGRAMUNIFORM4IV>(gapic::GetGfxProcAddress("glProgramUniform4iv", false));
        glProgramUniform4ui = reinterpret_cast<PFNGLPROGRAMUNIFORM4UI>(gapic::GetGfxProcAddress("glProgramUniform4ui", false));
        glProgramUniform4uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM4UIV>(gapic::GetGfxProcAddress("glProgramUniform4uiv", false));
        glProgramUniformMatrix2fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix2fv", false));
        glProgramUniformMatrix2x3fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X3FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix2x3fv", false));
        glProgramUniformMatrix2x4fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X4FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix2x4fv", false));
        glProgramUniformMatrix3fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix3fv", false));
        glProgramUniformMatrix3x2fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X2FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix3x2fv", false));
        glProgramUniformMatrix3x4fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X4FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix3x4fv", false));
        glProgramUniformMatrix4fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix4fv", false));
        glProgramUniformMatrix4x2fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X2FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix4x2fv", false));
        glProgramUniformMatrix4x3fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X3FV>(gapic::GetGfxProcAddress("glProgramUniformMatrix4x3fv", false));
        glReleaseShaderCompiler = reinterpret_cast<PFNGLRELEASESHADERCOMPILER>(gapic::GetGfxProcAddress("glReleaseShaderCompiler", false));
        glShaderBinary = reinterpret_cast<PFNGLSHADERBINARY>(gapic::GetGfxProcAddress("glShaderBinary", false));
        glShaderSource = reinterpret_cast<PFNGLSHADERSOURCE>(gapic::GetGfxProcAddress("glShaderSource", false));
        glUniform1f = reinterpret_cast<PFNGLUNIFORM1F>(gapic::GetGfxProcAddress("glUniform1f", false));
        glUniform1fv = reinterpret_cast<PFNGLUNIFORM1FV>(gapic::GetGfxProcAddress("glUniform1fv", false));
        glUniform1i = reinterpret_cast<PFNGLUNIFORM1I>(gapic::GetGfxProcAddress("glUniform1i", false));
        glUniform1iv = reinterpret_cast<PFNGLUNIFORM1IV>(gapic::GetGfxProcAddress("glUniform1iv", false));
        glUniform1ui = reinterpret_cast<PFNGLUNIFORM1UI>(gapic::GetGfxProcAddress("glUniform1ui", false));
        glUniform1uiv = reinterpret_cast<PFNGLUNIFORM1UIV>(gapic::GetGfxProcAddress("glUniform1uiv", false));
        glUniform2f = reinterpret_cast<PFNGLUNIFORM2F>(gapic::GetGfxProcAddress("glUniform2f", false));
        glUniform2fv = reinterpret_cast<PFNGLUNIFORM2FV>(gapic::GetGfxProcAddress("glUniform2fv", false));
        glUniform2i = reinterpret_cast<PFNGLUNIFORM2I>(gapic::GetGfxProcAddress("glUniform2i", false));
        glUniform2iv = reinterpret_cast<PFNGLUNIFORM2IV>(gapic::GetGfxProcAddress("glUniform2iv", false));
        glUniform2ui = reinterpret_cast<PFNGLUNIFORM2UI>(gapic::GetGfxProcAddress("glUniform2ui", false));
        glUniform2uiv = reinterpret_cast<PFNGLUNIFORM2UIV>(gapic::GetGfxProcAddress("glUniform2uiv", false));
        glUniform3f = reinterpret_cast<PFNGLUNIFORM3F>(gapic::GetGfxProcAddress("glUniform3f", false));
        glUniform3fv = reinterpret_cast<PFNGLUNIFORM3FV>(gapic::GetGfxProcAddress("glUniform3fv", false));
        glUniform3i = reinterpret_cast<PFNGLUNIFORM3I>(gapic::GetGfxProcAddress("glUniform3i", false));
        glUniform3iv = reinterpret_cast<PFNGLUNIFORM3IV>(gapic::GetGfxProcAddress("glUniform3iv", false));
        glUniform3ui = reinterpret_cast<PFNGLUNIFORM3UI>(gapic::GetGfxProcAddress("glUniform3ui", false));
        glUniform3uiv = reinterpret_cast<PFNGLUNIFORM3UIV>(gapic::GetGfxProcAddress("glUniform3uiv", false));
        glUniform4f = reinterpret_cast<PFNGLUNIFORM4F>(gapic::GetGfxProcAddress("glUniform4f", false));
        glUniform4fv = reinterpret_cast<PFNGLUNIFORM4FV>(gapic::GetGfxProcAddress("glUniform4fv", false));
        glUniform4i = reinterpret_cast<PFNGLUNIFORM4I>(gapic::GetGfxProcAddress("glUniform4i", false));
        glUniform4iv = reinterpret_cast<PFNGLUNIFORM4IV>(gapic::GetGfxProcAddress("glUniform4iv", false));
        glUniform4ui = reinterpret_cast<PFNGLUNIFORM4UI>(gapic::GetGfxProcAddress("glUniform4ui", false));
        glUniform4uiv = reinterpret_cast<PFNGLUNIFORM4UIV>(gapic::GetGfxProcAddress("glUniform4uiv", false));
        glUniformBlockBinding = reinterpret_cast<PFNGLUNIFORMBLOCKBINDING>(gapic::GetGfxProcAddress("glUniformBlockBinding", false));
        glUniformMatrix2fv = reinterpret_cast<PFNGLUNIFORMMATRIX2FV>(gapic::GetGfxProcAddress("glUniformMatrix2fv", false));
        glUniformMatrix2x3fv = reinterpret_cast<PFNGLUNIFORMMATRIX2X3FV>(gapic::GetGfxProcAddress("glUniformMatrix2x3fv", false));
        glUniformMatrix2x4fv = reinterpret_cast<PFNGLUNIFORMMATRIX2X4FV>(gapic::GetGfxProcAddress("glUniformMatrix2x4fv", false));
        glUniformMatrix3fv = reinterpret_cast<PFNGLUNIFORMMATRIX3FV>(gapic::GetGfxProcAddress("glUniformMatrix3fv", false));
        glUniformMatrix3x2fv = reinterpret_cast<PFNGLUNIFORMMATRIX3X2FV>(gapic::GetGfxProcAddress("glUniformMatrix3x2fv", false));
        glUniformMatrix3x4fv = reinterpret_cast<PFNGLUNIFORMMATRIX3X4FV>(gapic::GetGfxProcAddress("glUniformMatrix3x4fv", false));
        glUniformMatrix4fv = reinterpret_cast<PFNGLUNIFORMMATRIX4FV>(gapic::GetGfxProcAddress("glUniformMatrix4fv", false));
        glUniformMatrix4x2fv = reinterpret_cast<PFNGLUNIFORMMATRIX4X2FV>(gapic::GetGfxProcAddress("glUniformMatrix4x2fv", false));
        glUniformMatrix4x3fv = reinterpret_cast<PFNGLUNIFORMMATRIX4X3FV>(gapic::GetGfxProcAddress("glUniformMatrix4x3fv", false));
        glUseProgram = reinterpret_cast<PFNGLUSEPROGRAM>(gapic::GetGfxProcAddress("glUseProgram", false));
        glUseProgramStages = reinterpret_cast<PFNGLUSEPROGRAMSTAGES>(gapic::GetGfxProcAddress("glUseProgramStages", false));
        glValidateProgram = reinterpret_cast<PFNGLVALIDATEPROGRAM>(gapic::GetGfxProcAddress("glValidateProgram", false));
        glValidateProgramPipeline = reinterpret_cast<PFNGLVALIDATEPROGRAMPIPELINE>(gapic::GetGfxProcAddress("glValidateProgramPipeline", false));
        glCullFace = reinterpret_cast<PFNGLCULLFACE>(gapic::GetGfxProcAddress("glCullFace", false));
        glDepthRangef = reinterpret_cast<PFNGLDEPTHRANGEF>(gapic::GetGfxProcAddress("glDepthRangef", false));
        glFrontFace = reinterpret_cast<PFNGLFRONTFACE>(gapic::GetGfxProcAddress("glFrontFace", false));
        glGetMultisamplefv = reinterpret_cast<PFNGLGETMULTISAMPLEFV>(gapic::GetGfxProcAddress("glGetMultisamplefv", false));
        glLineWidth = reinterpret_cast<PFNGLLINEWIDTH>(gapic::GetGfxProcAddress("glLineWidth", false));
        glMinSampleShading = reinterpret_cast<PFNGLMINSAMPLESHADING>(gapic::GetGfxProcAddress("glMinSampleShading", false));
        glPolygonOffset = reinterpret_cast<PFNGLPOLYGONOFFSET>(gapic::GetGfxProcAddress("glPolygonOffset", false));
        glViewport = reinterpret_cast<PFNGLVIEWPORT>(gapic::GetGfxProcAddress("glViewport", false));
        glGetBooleani_v = reinterpret_cast<PFNGLGETBOOLEANI_V>(gapic::GetGfxProcAddress("glGetBooleani_v", false));
        glGetBooleanv = reinterpret_cast<PFNGLGETBOOLEANV>(gapic::GetGfxProcAddress("glGetBooleanv", false));
        glGetFloatv = reinterpret_cast<PFNGLGETFLOATV>(gapic::GetGfxProcAddress("glGetFloatv", false));
        glGetInteger64i_v = reinterpret_cast<PFNGLGETINTEGER64I_V>(gapic::GetGfxProcAddress("glGetInteger64i_v", false));
        glGetInteger64v = reinterpret_cast<PFNGLGETINTEGER64V>(gapic::GetGfxProcAddress("glGetInteger64v", false));
        glGetIntegeri_v = reinterpret_cast<PFNGLGETINTEGERI_V>(gapic::GetGfxProcAddress("glGetIntegeri_v", false));
        glGetIntegerv = reinterpret_cast<PFNGLGETINTEGERV>(gapic::GetGfxProcAddress("glGetIntegerv", false));
        glGetInternalformativ = reinterpret_cast<PFNGLGETINTERNALFORMATIV>(gapic::GetGfxProcAddress("glGetInternalformativ", false));
        glGetString = reinterpret_cast<PFNGLGETSTRING>(gapic::GetGfxProcAddress("glGetString", false));
        glGetStringi = reinterpret_cast<PFNGLGETSTRINGI>(gapic::GetGfxProcAddress("glGetStringi", false));
        glIsEnabled = reinterpret_cast<PFNGLISENABLED>(gapic::GetGfxProcAddress("glIsEnabled", false));
        glIsEnabledi = reinterpret_cast<PFNGLISENABLEDI>(gapic::GetGfxProcAddress("glIsEnabledi", false));
        glClientWaitSync = reinterpret_cast<PFNGLCLIENTWAITSYNC>(gapic::GetGfxProcAddress("glClientWaitSync", false));
        glDeleteSync = reinterpret_cast<PFNGLDELETESYNC>(gapic::GetGfxProcAddress("glDeleteSync", false));
        glFenceSync = reinterpret_cast<PFNGLFENCESYNC>(gapic::GetGfxProcAddress("glFenceSync", false));
        glGetSynciv = reinterpret_cast<PFNGLGETSYNCIV>(gapic::GetGfxProcAddress("glGetSynciv", false));
        glIsSync = reinterpret_cast<PFNGLISSYNC>(gapic::GetGfxProcAddress("glIsSync", false));
        glWaitSync = reinterpret_cast<PFNGLWAITSYNC>(gapic::GetGfxProcAddress("glWaitSync", false));
        glActiveTexture = reinterpret_cast<PFNGLACTIVETEXTURE>(gapic::GetGfxProcAddress("glActiveTexture", false));
        glBindImageTexture = reinterpret_cast<PFNGLBINDIMAGETEXTURE>(gapic::GetGfxProcAddress("glBindImageTexture", false));
        glBindSampler = reinterpret_cast<PFNGLBINDSAMPLER>(gapic::GetGfxProcAddress("glBindSampler", false));
        glBindTexture = reinterpret_cast<PFNGLBINDTEXTURE>(gapic::GetGfxProcAddress("glBindTexture", false));
        glCompressedTexImage2D = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE2D>(gapic::GetGfxProcAddress("glCompressedTexImage2D", false));
        glCompressedTexImage3D = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE3D>(gapic::GetGfxProcAddress("glCompressedTexImage3D", false));
        glCompressedTexSubImage2D = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE2D>(gapic::GetGfxProcAddress("glCompressedTexSubImage2D", false));
        glCompressedTexSubImage3D = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE3D>(gapic::GetGfxProcAddress("glCompressedTexSubImage3D", false));
        glCopyImageSubData = reinterpret_cast<PFNGLCOPYIMAGESUBDATA>(gapic::GetGfxProcAddress("glCopyImageSubData", false));
        glCopyTexImage2D = reinterpret_cast<PFNGLCOPYTEXIMAGE2D>(gapic::GetGfxProcAddress("glCopyTexImage2D", false));
        glCopyTexSubImage2D = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE2D>(gapic::GetGfxProcAddress("glCopyTexSubImage2D", false));
        glCopyTexSubImage3D = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE3D>(gapic::GetGfxProcAddress("glCopyTexSubImage3D", false));
        glDeleteSamplers = reinterpret_cast<PFNGLDELETESAMPLERS>(gapic::GetGfxProcAddress("glDeleteSamplers", false));
        glDeleteTextures = reinterpret_cast<PFNGLDELETETEXTURES>(gapic::GetGfxProcAddress("glDeleteTextures", false));
        glGenSamplers = reinterpret_cast<PFNGLGENSAMPLERS>(gapic::GetGfxProcAddress("glGenSamplers", false));
        glGenTextures = reinterpret_cast<PFNGLGENTEXTURES>(gapic::GetGfxProcAddress("glGenTextures", false));
        glGenerateMipmap = reinterpret_cast<PFNGLGENERATEMIPMAP>(gapic::GetGfxProcAddress("glGenerateMipmap", false));
        glGetSamplerParameterIiv = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIIV>(gapic::GetGfxProcAddress("glGetSamplerParameterIiv", false));
        glGetSamplerParameterIuiv = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIUIV>(gapic::GetGfxProcAddress("glGetSamplerParameterIuiv", false));
        glGetSamplerParameterfv = reinterpret_cast<PFNGLGETSAMPLERPARAMETERFV>(gapic::GetGfxProcAddress("glGetSamplerParameterfv", false));
        glGetSamplerParameteriv = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIV>(gapic::GetGfxProcAddress("glGetSamplerParameteriv", false));
        glGetTexLevelParameterfv = reinterpret_cast<PFNGLGETTEXLEVELPARAMETERFV>(gapic::GetGfxProcAddress("glGetTexLevelParameterfv", false));
        glGetTexLevelParameteriv = reinterpret_cast<PFNGLGETTEXLEVELPARAMETERIV>(gapic::GetGfxProcAddress("glGetTexLevelParameteriv", false));
        glGetTexParameterIiv = reinterpret_cast<PFNGLGETTEXPARAMETERIIV>(gapic::GetGfxProcAddress("glGetTexParameterIiv", false));
        glGetTexParameterIuiv = reinterpret_cast<PFNGLGETTEXPARAMETERIUIV>(gapic::GetGfxProcAddress("glGetTexParameterIuiv", false));
        glGetTexParameterfv = reinterpret_cast<PFNGLGETTEXPARAMETERFV>(gapic::GetGfxProcAddress("glGetTexParameterfv", false));
        glGetTexParameteriv = reinterpret_cast<PFNGLGETTEXPARAMETERIV>(gapic::GetGfxProcAddress("glGetTexParameteriv", false));
        glIsSampler = reinterpret_cast<PFNGLISSAMPLER>(gapic::GetGfxProcAddress("glIsSampler", false));
        glIsTexture = reinterpret_cast<PFNGLISTEXTURE>(gapic::GetGfxProcAddress("glIsTexture", false));
        glPixelStorei = reinterpret_cast<PFNGLPIXELSTOREI>(gapic::GetGfxProcAddress("glPixelStorei", false));
        glSamplerParameterIiv = reinterpret_cast<PFNGLSAMPLERPARAMETERIIV>(gapic::GetGfxProcAddress("glSamplerParameterIiv", false));
        glSamplerParameterIuiv = reinterpret_cast<PFNGLSAMPLERPARAMETERIUIV>(gapic::GetGfxProcAddress("glSamplerParameterIuiv", false));
        glSamplerParameterf = reinterpret_cast<PFNGLSAMPLERPARAMETERF>(gapic::GetGfxProcAddress("glSamplerParameterf", false));
        glSamplerParameterfv = reinterpret_cast<PFNGLSAMPLERPARAMETERFV>(gapic::GetGfxProcAddress("glSamplerParameterfv", false));
        glSamplerParameteri = reinterpret_cast<PFNGLSAMPLERPARAMETERI>(gapic::GetGfxProcAddress("glSamplerParameteri", false));
        glSamplerParameteriv = reinterpret_cast<PFNGLSAMPLERPARAMETERIV>(gapic::GetGfxProcAddress("glSamplerParameteriv", false));
        glTexBuffer = reinterpret_cast<PFNGLTEXBUFFER>(gapic::GetGfxProcAddress("glTexBuffer", false));
        glTexBufferRange = reinterpret_cast<PFNGLTEXBUFFERRANGE>(gapic::GetGfxProcAddress("glTexBufferRange", false));
        glTexImage2D = reinterpret_cast<PFNGLTEXIMAGE2D>(gapic::GetGfxProcAddress("glTexImage2D", false));
        glTexImage3D = reinterpret_cast<PFNGLTEXIMAGE3D>(gapic::GetGfxProcAddress("glTexImage3D", false));
        glTexParameterIiv = reinterpret_cast<PFNGLTEXPARAMETERIIV>(gapic::GetGfxProcAddress("glTexParameterIiv", false));
        glTexParameterIuiv = reinterpret_cast<PFNGLTEXPARAMETERIUIV>(gapic::GetGfxProcAddress("glTexParameterIuiv", false));
        glTexParameterf = reinterpret_cast<PFNGLTEXPARAMETERF>(gapic::GetGfxProcAddress("glTexParameterf", false));
        glTexParameterfv = reinterpret_cast<PFNGLTEXPARAMETERFV>(gapic::GetGfxProcAddress("glTexParameterfv", false));
        glTexParameteri = reinterpret_cast<PFNGLTEXPARAMETERI>(gapic::GetGfxProcAddress("glTexParameteri", false));
        glTexParameteriv = reinterpret_cast<PFNGLTEXPARAMETERIV>(gapic::GetGfxProcAddress("glTexParameteriv", false));
        glTexStorage2D = reinterpret_cast<PFNGLTEXSTORAGE2D>(gapic::GetGfxProcAddress("glTexStorage2D", false));
        glTexStorage2DMultisample = reinterpret_cast<PFNGLTEXSTORAGE2DMULTISAMPLE>(gapic::GetGfxProcAddress("glTexStorage2DMultisample", false));
        glTexStorage3D = reinterpret_cast<PFNGLTEXSTORAGE3D>(gapic::GetGfxProcAddress("glTexStorage3D", false));
        glTexStorage3DMultisample = reinterpret_cast<PFNGLTEXSTORAGE3DMULTISAMPLE>(gapic::GetGfxProcAddress("glTexStorage3DMultisample", false));
        glTexSubImage2D = reinterpret_cast<PFNGLTEXSUBIMAGE2D>(gapic::GetGfxProcAddress("glTexSubImage2D", false));
        glTexSubImage3D = reinterpret_cast<PFNGLTEXSUBIMAGE3D>(gapic::GetGfxProcAddress("glTexSubImage3D", false));
        glBeginTransformFeedback = reinterpret_cast<PFNGLBEGINTRANSFORMFEEDBACK>(gapic::GetGfxProcAddress("glBeginTransformFeedback", false));
        glBindTransformFeedback = reinterpret_cast<PFNGLBINDTRANSFORMFEEDBACK>(gapic::GetGfxProcAddress("glBindTransformFeedback", false));
        glDeleteTransformFeedbacks = reinterpret_cast<PFNGLDELETETRANSFORMFEEDBACKS>(gapic::GetGfxProcAddress("glDeleteTransformFeedbacks", false));
        glEndTransformFeedback = reinterpret_cast<PFNGLENDTRANSFORMFEEDBACK>(gapic::GetGfxProcAddress("glEndTransformFeedback", false));
        glGenTransformFeedbacks = reinterpret_cast<PFNGLGENTRANSFORMFEEDBACKS>(gapic::GetGfxProcAddress("glGenTransformFeedbacks", false));
        glGetTransformFeedbackVarying = reinterpret_cast<PFNGLGETTRANSFORMFEEDBACKVARYING>(gapic::GetGfxProcAddress("glGetTransformFeedbackVarying", false));
        glIsTransformFeedback = reinterpret_cast<PFNGLISTRANSFORMFEEDBACK>(gapic::GetGfxProcAddress("glIsTransformFeedback", false));
        glPauseTransformFeedback = reinterpret_cast<PFNGLPAUSETRANSFORMFEEDBACK>(gapic::GetGfxProcAddress("glPauseTransformFeedback", false));
        glResumeTransformFeedback = reinterpret_cast<PFNGLRESUMETRANSFORMFEEDBACK>(gapic::GetGfxProcAddress("glResumeTransformFeedback", false));
        glTransformFeedbackVaryings = reinterpret_cast<PFNGLTRANSFORMFEEDBACKVARYINGS>(gapic::GetGfxProcAddress("glTransformFeedbackVaryings", false));
        glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAY>(gapic::GetGfxProcAddress("glBindVertexArray", false));
        glBindVertexBuffer = reinterpret_cast<PFNGLBINDVERTEXBUFFER>(gapic::GetGfxProcAddress("glBindVertexBuffer", false));
        glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYS>(gapic::GetGfxProcAddress("glDeleteVertexArrays", false));
        glDisableVertexAttribArray = reinterpret_cast<PFNGLDISABLEVERTEXATTRIBARRAY>(gapic::GetGfxProcAddress("glDisableVertexAttribArray", false));
        glEnableVertexAttribArray = reinterpret_cast<PFNGLENABLEVERTEXATTRIBARRAY>(gapic::GetGfxProcAddress("glEnableVertexAttribArray", false));
        glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYS>(gapic::GetGfxProcAddress("glGenVertexArrays", false));
        glGetVertexAttribIiv = reinterpret_cast<PFNGLGETVERTEXATTRIBIIV>(gapic::GetGfxProcAddress("glGetVertexAttribIiv", false));
        glGetVertexAttribIuiv = reinterpret_cast<PFNGLGETVERTEXATTRIBIUIV>(gapic::GetGfxProcAddress("glGetVertexAttribIuiv", false));
        glGetVertexAttribPointerv = reinterpret_cast<PFNGLGETVERTEXATTRIBPOINTERV>(gapic::GetGfxProcAddress("glGetVertexAttribPointerv", false));
        glGetVertexAttribfv = reinterpret_cast<PFNGLGETVERTEXATTRIBFV>(gapic::GetGfxProcAddress("glGetVertexAttribfv", false));
        glGetVertexAttribiv = reinterpret_cast<PFNGLGETVERTEXATTRIBIV>(gapic::GetGfxProcAddress("glGetVertexAttribiv", false));
        glIsVertexArray = reinterpret_cast<PFNGLISVERTEXARRAY>(gapic::GetGfxProcAddress("glIsVertexArray", false));
        glVertexAttrib1f = reinterpret_cast<PFNGLVERTEXATTRIB1F>(gapic::GetGfxProcAddress("glVertexAttrib1f", false));
        glVertexAttrib1fv = reinterpret_cast<PFNGLVERTEXATTRIB1FV>(gapic::GetGfxProcAddress("glVertexAttrib1fv", false));
        glVertexAttrib2f = reinterpret_cast<PFNGLVERTEXATTRIB2F>(gapic::GetGfxProcAddress("glVertexAttrib2f", false));
        glVertexAttrib2fv = reinterpret_cast<PFNGLVERTEXATTRIB2FV>(gapic::GetGfxProcAddress("glVertexAttrib2fv", false));
        glVertexAttrib3f = reinterpret_cast<PFNGLVERTEXATTRIB3F>(gapic::GetGfxProcAddress("glVertexAttrib3f", false));
        glVertexAttrib3fv = reinterpret_cast<PFNGLVERTEXATTRIB3FV>(gapic::GetGfxProcAddress("glVertexAttrib3fv", false));
        glVertexAttrib4f = reinterpret_cast<PFNGLVERTEXATTRIB4F>(gapic::GetGfxProcAddress("glVertexAttrib4f", false));
        glVertexAttrib4fv = reinterpret_cast<PFNGLVERTEXATTRIB4FV>(gapic::GetGfxProcAddress("glVertexAttrib4fv", false));
        glVertexAttribBinding = reinterpret_cast<PFNGLVERTEXATTRIBBINDING>(gapic::GetGfxProcAddress("glVertexAttribBinding", false));
        glVertexAttribDivisor = reinterpret_cast<PFNGLVERTEXATTRIBDIVISOR>(gapic::GetGfxProcAddress("glVertexAttribDivisor", false));
        glVertexAttribFormat = reinterpret_cast<PFNGLVERTEXATTRIBFORMAT>(gapic::GetGfxProcAddress("glVertexAttribFormat", false));
        glVertexAttribI4i = reinterpret_cast<PFNGLVERTEXATTRIBI4I>(gapic::GetGfxProcAddress("glVertexAttribI4i", false));
        glVertexAttribI4iv = reinterpret_cast<PFNGLVERTEXATTRIBI4IV>(gapic::GetGfxProcAddress("glVertexAttribI4iv", false));
        glVertexAttribI4ui = reinterpret_cast<PFNGLVERTEXATTRIBI4UI>(gapic::GetGfxProcAddress("glVertexAttribI4ui", false));
        glVertexAttribI4uiv = reinterpret_cast<PFNGLVERTEXATTRIBI4UIV>(gapic::GetGfxProcAddress("glVertexAttribI4uiv", false));
        glVertexAttribIFormat = reinterpret_cast<PFNGLVERTEXATTRIBIFORMAT>(gapic::GetGfxProcAddress("glVertexAttribIFormat", false));
        glVertexAttribIPointer = reinterpret_cast<PFNGLVERTEXATTRIBIPOINTER>(gapic::GetGfxProcAddress("glVertexAttribIPointer", false));
        glVertexAttribPointer = reinterpret_cast<PFNGLVERTEXATTRIBPOINTER>(gapic::GetGfxProcAddress("glVertexAttribPointer", false));
        glVertexBindingDivisor = reinterpret_cast<PFNGLVERTEXBINDINGDIVISOR>(gapic::GetGfxProcAddress("glVertexBindingDivisor", false));
        eglInitialize = reinterpret_cast<PFNEGLINITIALIZE>(gapic::GetGfxProcAddress("eglInitialize", false));
        eglCreateContext = reinterpret_cast<PFNEGLCREATECONTEXT>(gapic::GetGfxProcAddress("eglCreateContext", false));
        eglMakeCurrent = reinterpret_cast<PFNEGLMAKECURRENT>(gapic::GetGfxProcAddress("eglMakeCurrent", false));
        eglSwapBuffers = reinterpret_cast<PFNEGLSWAPBUFFERS>(gapic::GetGfxProcAddress("eglSwapBuffers", false));
        eglSwapBuffersWithDamageKHR = reinterpret_cast<PFNEGLSWAPBUFFERSWITHDAMAGEKHR>(gapic::GetGfxProcAddress("eglSwapBuffersWithDamageKHR", false));
        eglQuerySurface = reinterpret_cast<PFNEGLQUERYSURFACE>(gapic::GetGfxProcAddress("eglQuerySurface", false));
        eglQueryContext = reinterpret_cast<PFNEGLQUERYCONTEXT>(gapic::GetGfxProcAddress("eglQueryContext", false));
        eglChooseConfig = reinterpret_cast<PFNEGLCHOOSECONFIG>(gapic::GetGfxProcAddress("eglChooseConfig", false));
        eglGetConfigAttrib = reinterpret_cast<PFNEGLGETCONFIGATTRIB>(gapic::GetGfxProcAddress("eglGetConfigAttrib", false));
        glXCreateContext = reinterpret_cast<PFNGLXCREATECONTEXT>(gapic::GetGfxProcAddress("glXCreateContext", false));
        glXCreateNewContext = reinterpret_cast<PFNGLXCREATENEWCONTEXT>(gapic::GetGfxProcAddress("glXCreateNewContext", false));
        glXMakeContextCurrent = reinterpret_cast<PFNGLXMAKECONTEXTCURRENT>(gapic::GetGfxProcAddress("glXMakeContextCurrent", false));
        glXMakeCurrent = reinterpret_cast<PFNGLXMAKECURRENT>(gapic::GetGfxProcAddress("glXMakeCurrent", false));
        glXSwapBuffers = reinterpret_cast<PFNGLXSWAPBUFFERS>(gapic::GetGfxProcAddress("glXSwapBuffers", false));
        glXQueryDrawable = reinterpret_cast<PFNGLXQUERYDRAWABLE>(gapic::GetGfxProcAddress("glXQueryDrawable", false));
        wglCreateContext = reinterpret_cast<PFNWGLCREATECONTEXT>(gapic::GetGfxProcAddress("wglCreateContext", false));
        wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARB>(gapic::GetGfxProcAddress("wglCreateContextAttribsARB", false));
        wglMakeCurrent = reinterpret_cast<PFNWGLMAKECURRENT>(gapic::GetGfxProcAddress("wglMakeCurrent", false));
        wglSwapBuffers = reinterpret_cast<PFNWGLSWAPBUFFERS>(gapic::GetGfxProcAddress("wglSwapBuffers", false));
        CGLCreateContext = reinterpret_cast<PFNCGLCREATECONTEXT>(gapic::GetGfxProcAddress("CGLCreateContext", false));
        CGLSetCurrentContext = reinterpret_cast<PFNCGLSETCURRENTCONTEXT>(gapic::GetGfxProcAddress("CGLSetCurrentContext", false));
        CGLGetSurface = reinterpret_cast<PFNCGLGETSURFACE>(gapic::GetGfxProcAddress("CGLGetSurface", false));
        CGSGetSurfaceBounds = reinterpret_cast<PFNCGSGETSURFACEBOUNDS>(gapic::GetGfxProcAddress("CGSGetSurfaceBounds", false));
        CGLFlushDrawable = reinterpret_cast<PFNCGLFLUSHDRAWABLE>(gapic::GetGfxProcAddress("CGLFlushDrawable", false));
        glGetQueryObjecti64v = reinterpret_cast<PFNGLGETQUERYOBJECTI64V>(gapic::GetGfxProcAddress("glGetQueryObjecti64v", false));
        glGetQueryObjectui64v = reinterpret_cast<PFNGLGETQUERYOBJECTUI64V>(gapic::GetGfxProcAddress("glGetQueryObjectui64v", false));
        glAlphaFunc = reinterpret_cast<PFNGLALPHAFUNC>(gapic::GetGfxProcAddress("glAlphaFunc", false));
        glAlphaFuncx = reinterpret_cast<PFNGLALPHAFUNCX>(gapic::GetGfxProcAddress("glAlphaFuncx", false));
        glAlphaFuncxOES = reinterpret_cast<PFNGLALPHAFUNCXOES>(gapic::GetGfxProcAddress("glAlphaFuncxOES", false));
        glBindFramebufferOES = reinterpret_cast<PFNGLBINDFRAMEBUFFEROES>(gapic::GetGfxProcAddress("glBindFramebufferOES", false));
        glBindRenderbufferOES = reinterpret_cast<PFNGLBINDRENDERBUFFEROES>(gapic::GetGfxProcAddress("glBindRenderbufferOES", false));
        glBlendEquationOES = reinterpret_cast<PFNGLBLENDEQUATIONOES>(gapic::GetGfxProcAddress("glBlendEquationOES", false));
        glBlendEquationSeparateOES = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEOES>(gapic::GetGfxProcAddress("glBlendEquationSeparateOES", false));
        glBlendFuncSeparateOES = reinterpret_cast<PFNGLBLENDFUNCSEPARATEOES>(gapic::GetGfxProcAddress("glBlendFuncSeparateOES", false));
        glCheckFramebufferStatusOES = reinterpret_cast<PFNGLCHECKFRAMEBUFFERSTATUSOES>(gapic::GetGfxProcAddress("glCheckFramebufferStatusOES", false));
        glClearColorx = reinterpret_cast<PFNGLCLEARCOLORX>(gapic::GetGfxProcAddress("glClearColorx", false));
        glClearColorxOES = reinterpret_cast<PFNGLCLEARCOLORXOES>(gapic::GetGfxProcAddress("glClearColorxOES", false));
        glClearDepthfOES = reinterpret_cast<PFNGLCLEARDEPTHFOES>(gapic::GetGfxProcAddress("glClearDepthfOES", false));
        glClearDepthx = reinterpret_cast<PFNGLCLEARDEPTHX>(gapic::GetGfxProcAddress("glClearDepthx", false));
        glClearDepthxOES = reinterpret_cast<PFNGLCLEARDEPTHXOES>(gapic::GetGfxProcAddress("glClearDepthxOES", false));
        glClientActiveTexture = reinterpret_cast<PFNGLCLIENTACTIVETEXTURE>(gapic::GetGfxProcAddress("glClientActiveTexture", false));
        glClipPlanef = reinterpret_cast<PFNGLCLIPPLANEF>(gapic::GetGfxProcAddress("glClipPlanef", false));
        glClipPlanefIMG = reinterpret_cast<PFNGLCLIPPLANEFIMG>(gapic::GetGfxProcAddress("glClipPlanefIMG", false));
        glClipPlanefOES = reinterpret_cast<PFNGLCLIPPLANEFOES>(gapic::GetGfxProcAddress("glClipPlanefOES", false));
        glClipPlanex = reinterpret_cast<PFNGLCLIPPLANEX>(gapic::GetGfxProcAddress("glClipPlanex", false));
        glClipPlanexIMG = reinterpret_cast<PFNGLCLIPPLANEXIMG>(gapic::GetGfxProcAddress("glClipPlanexIMG", false));
        glClipPlanexOES = reinterpret_cast<PFNGLCLIPPLANEXOES>(gapic::GetGfxProcAddress("glClipPlanexOES", false));
        glColor4f = reinterpret_cast<PFNGLCOLOR4F>(gapic::GetGfxProcAddress("glColor4f", false));
        glColor4ub = reinterpret_cast<PFNGLCOLOR4UB>(gapic::GetGfxProcAddress("glColor4ub", false));
        glColor4x = reinterpret_cast<PFNGLCOLOR4X>(gapic::GetGfxProcAddress("glColor4x", false));
        glColor4xOES = reinterpret_cast<PFNGLCOLOR4XOES>(gapic::GetGfxProcAddress("glColor4xOES", false));
        glColorPointer = reinterpret_cast<PFNGLCOLORPOINTER>(gapic::GetGfxProcAddress("glColorPointer", false));
        glCurrentPaletteMatrixOES = reinterpret_cast<PFNGLCURRENTPALETTEMATRIXOES>(gapic::GetGfxProcAddress("glCurrentPaletteMatrixOES", false));
        glDeleteFramebuffersOES = reinterpret_cast<PFNGLDELETEFRAMEBUFFERSOES>(gapic::GetGfxProcAddress("glDeleteFramebuffersOES", false));
        glDeleteRenderbuffersOES = reinterpret_cast<PFNGLDELETERENDERBUFFERSOES>(gapic::GetGfxProcAddress("glDeleteRenderbuffersOES", false));
        glDepthRangefOES = reinterpret_cast<PFNGLDEPTHRANGEFOES>(gapic::GetGfxProcAddress("glDepthRangefOES", false));
        glDepthRangex = reinterpret_cast<PFNGLDEPTHRANGEX>(gapic::GetGfxProcAddress("glDepthRangex", false));
        glDepthRangexOES = reinterpret_cast<PFNGLDEPTHRANGEXOES>(gapic::GetGfxProcAddress("glDepthRangexOES", false));
        glDisableClientState = reinterpret_cast<PFNGLDISABLECLIENTSTATE>(gapic::GetGfxProcAddress("glDisableClientState", false));
        glDrawTexfOES = reinterpret_cast<PFNGLDRAWTEXFOES>(gapic::GetGfxProcAddress("glDrawTexfOES", false));
        glDrawTexfvOES = reinterpret_cast<PFNGLDRAWTEXFVOES>(gapic::GetGfxProcAddress("glDrawTexfvOES", false));
        glDrawTexiOES = reinterpret_cast<PFNGLDRAWTEXIOES>(gapic::GetGfxProcAddress("glDrawTexiOES", false));
        glDrawTexivOES = reinterpret_cast<PFNGLDRAWTEXIVOES>(gapic::GetGfxProcAddress("glDrawTexivOES", false));
        glDrawTexsOES = reinterpret_cast<PFNGLDRAWTEXSOES>(gapic::GetGfxProcAddress("glDrawTexsOES", false));
        glDrawTexsvOES = reinterpret_cast<PFNGLDRAWTEXSVOES>(gapic::GetGfxProcAddress("glDrawTexsvOES", false));
        glDrawTexxOES = reinterpret_cast<PFNGLDRAWTEXXOES>(gapic::GetGfxProcAddress("glDrawTexxOES", false));
        glDrawTexxvOES = reinterpret_cast<PFNGLDRAWTEXXVOES>(gapic::GetGfxProcAddress("glDrawTexxvOES", false));
        glEnableClientState = reinterpret_cast<PFNGLENABLECLIENTSTATE>(gapic::GetGfxProcAddress("glEnableClientState", false));
        glFogf = reinterpret_cast<PFNGLFOGF>(gapic::GetGfxProcAddress("glFogf", false));
        glFogfv = reinterpret_cast<PFNGLFOGFV>(gapic::GetGfxProcAddress("glFogfv", false));
        glFogx = reinterpret_cast<PFNGLFOGX>(gapic::GetGfxProcAddress("glFogx", false));
        glFogxOES = reinterpret_cast<PFNGLFOGXOES>(gapic::GetGfxProcAddress("glFogxOES", false));
        glFogxv = reinterpret_cast<PFNGLFOGXV>(gapic::GetGfxProcAddress("glFogxv", false));
        glFogxvOES = reinterpret_cast<PFNGLFOGXVOES>(gapic::GetGfxProcAddress("glFogxvOES", false));
        glFramebufferRenderbufferOES = reinterpret_cast<PFNGLFRAMEBUFFERRENDERBUFFEROES>(gapic::GetGfxProcAddress("glFramebufferRenderbufferOES", false));
        glFramebufferTexture2DOES = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DOES>(gapic::GetGfxProcAddress("glFramebufferTexture2DOES", false));
        glFrustumf = reinterpret_cast<PFNGLFRUSTUMF>(gapic::GetGfxProcAddress("glFrustumf", false));
        glFrustumfOES = reinterpret_cast<PFNGLFRUSTUMFOES>(gapic::GetGfxProcAddress("glFrustumfOES", false));
        glFrustumx = reinterpret_cast<PFNGLFRUSTUMX>(gapic::GetGfxProcAddress("glFrustumx", false));
        glFrustumxOES = reinterpret_cast<PFNGLFRUSTUMXOES>(gapic::GetGfxProcAddress("glFrustumxOES", false));
        glGenFramebuffersOES = reinterpret_cast<PFNGLGENFRAMEBUFFERSOES>(gapic::GetGfxProcAddress("glGenFramebuffersOES", false));
        glGenRenderbuffersOES = reinterpret_cast<PFNGLGENRENDERBUFFERSOES>(gapic::GetGfxProcAddress("glGenRenderbuffersOES", false));
        glGenerateMipmapOES = reinterpret_cast<PFNGLGENERATEMIPMAPOES>(gapic::GetGfxProcAddress("glGenerateMipmapOES", false));
        glGetClipPlanef = reinterpret_cast<PFNGLGETCLIPPLANEF>(gapic::GetGfxProcAddress("glGetClipPlanef", false));
        glGetClipPlanefOES = reinterpret_cast<PFNGLGETCLIPPLANEFOES>(gapic::GetGfxProcAddress("glGetClipPlanefOES", false));
        glGetClipPlanex = reinterpret_cast<PFNGLGETCLIPPLANEX>(gapic::GetGfxProcAddress("glGetClipPlanex", false));
        glGetClipPlanexOES = reinterpret_cast<PFNGLGETCLIPPLANEXOES>(gapic::GetGfxProcAddress("glGetClipPlanexOES", false));
        glGetFixedv = reinterpret_cast<PFNGLGETFIXEDV>(gapic::GetGfxProcAddress("glGetFixedv", false));
        glGetFixedvOES = reinterpret_cast<PFNGLGETFIXEDVOES>(gapic::GetGfxProcAddress("glGetFixedvOES", false));
        glGetFramebufferAttachmentParameterivOES = reinterpret_cast<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOES>(gapic::GetGfxProcAddress("glGetFramebufferAttachmentParameterivOES", false));
        glGetLightfv = reinterpret_cast<PFNGLGETLIGHTFV>(gapic::GetGfxProcAddress("glGetLightfv", false));
        glGetLightxv = reinterpret_cast<PFNGLGETLIGHTXV>(gapic::GetGfxProcAddress("glGetLightxv", false));
        glGetLightxvOES = reinterpret_cast<PFNGLGETLIGHTXVOES>(gapic::GetGfxProcAddress("glGetLightxvOES", false));
        glGetMaterialfv = reinterpret_cast<PFNGLGETMATERIALFV>(gapic::GetGfxProcAddress("glGetMaterialfv", false));
        glGetMaterialxv = reinterpret_cast<PFNGLGETMATERIALXV>(gapic::GetGfxProcAddress("glGetMaterialxv", false));
        glGetMaterialxvOES = reinterpret_cast<PFNGLGETMATERIALXVOES>(gapic::GetGfxProcAddress("glGetMaterialxvOES", false));
        glGetRenderbufferParameterivOES = reinterpret_cast<PFNGLGETRENDERBUFFERPARAMETERIVOES>(gapic::GetGfxProcAddress("glGetRenderbufferParameterivOES", false));
        glGetTexEnvfv = reinterpret_cast<PFNGLGETTEXENVFV>(gapic::GetGfxProcAddress("glGetTexEnvfv", false));
        glGetTexEnviv = reinterpret_cast<PFNGLGETTEXENVIV>(gapic::GetGfxProcAddress("glGetTexEnviv", false));
        glGetTexEnvxv = reinterpret_cast<PFNGLGETTEXENVXV>(gapic::GetGfxProcAddress("glGetTexEnvxv", false));
        glGetTexEnvxvOES = reinterpret_cast<PFNGLGETTEXENVXVOES>(gapic::GetGfxProcAddress("glGetTexEnvxvOES", false));
        glGetTexGenfvOES = reinterpret_cast<PFNGLGETTEXGENFVOES>(gapic::GetGfxProcAddress("glGetTexGenfvOES", false));
        glGetTexGenivOES = reinterpret_cast<PFNGLGETTEXGENIVOES>(gapic::GetGfxProcAddress("glGetTexGenivOES", false));
        glGetTexGenxvOES = reinterpret_cast<PFNGLGETTEXGENXVOES>(gapic::GetGfxProcAddress("glGetTexGenxvOES", false));
        glGetTexParameterxv = reinterpret_cast<PFNGLGETTEXPARAMETERXV>(gapic::GetGfxProcAddress("glGetTexParameterxv", false));
        glGetTexParameterxvOES = reinterpret_cast<PFNGLGETTEXPARAMETERXVOES>(gapic::GetGfxProcAddress("glGetTexParameterxvOES", false));
        glIsFramebufferOES = reinterpret_cast<PFNGLISFRAMEBUFFEROES>(gapic::GetGfxProcAddress("glIsFramebufferOES", false));
        glIsRenderbufferOES = reinterpret_cast<PFNGLISRENDERBUFFEROES>(gapic::GetGfxProcAddress("glIsRenderbufferOES", false));
        glLightModelf = reinterpret_cast<PFNGLLIGHTMODELF>(gapic::GetGfxProcAddress("glLightModelf", false));
        glLightModelfv = reinterpret_cast<PFNGLLIGHTMODELFV>(gapic::GetGfxProcAddress("glLightModelfv", false));
        glLightModelx = reinterpret_cast<PFNGLLIGHTMODELX>(gapic::GetGfxProcAddress("glLightModelx", false));
        glLightModelxOES = reinterpret_cast<PFNGLLIGHTMODELXOES>(gapic::GetGfxProcAddress("glLightModelxOES", false));
        glLightModelxv = reinterpret_cast<PFNGLLIGHTMODELXV>(gapic::GetGfxProcAddress("glLightModelxv", false));
        glLightModelxvOES = reinterpret_cast<PFNGLLIGHTMODELXVOES>(gapic::GetGfxProcAddress("glLightModelxvOES", false));
        glLightf = reinterpret_cast<PFNGLLIGHTF>(gapic::GetGfxProcAddress("glLightf", false));
        glLightfv = reinterpret_cast<PFNGLLIGHTFV>(gapic::GetGfxProcAddress("glLightfv", false));
        glLightx = reinterpret_cast<PFNGLLIGHTX>(gapic::GetGfxProcAddress("glLightx", false));
        glLightxOES = reinterpret_cast<PFNGLLIGHTXOES>(gapic::GetGfxProcAddress("glLightxOES", false));
        glLightxv = reinterpret_cast<PFNGLLIGHTXV>(gapic::GetGfxProcAddress("glLightxv", false));
        glLightxvOES = reinterpret_cast<PFNGLLIGHTXVOES>(gapic::GetGfxProcAddress("glLightxvOES", false));
        glLineWidthx = reinterpret_cast<PFNGLLINEWIDTHX>(gapic::GetGfxProcAddress("glLineWidthx", false));
        glLineWidthxOES = reinterpret_cast<PFNGLLINEWIDTHXOES>(gapic::GetGfxProcAddress("glLineWidthxOES", false));
        glLoadIdentity = reinterpret_cast<PFNGLLOADIDENTITY>(gapic::GetGfxProcAddress("glLoadIdentity", false));
        glLoadMatrixf = reinterpret_cast<PFNGLLOADMATRIXF>(gapic::GetGfxProcAddress("glLoadMatrixf", false));
        glLoadMatrixx = reinterpret_cast<PFNGLLOADMATRIXX>(gapic::GetGfxProcAddress("glLoadMatrixx", false));
        glLoadMatrixxOES = reinterpret_cast<PFNGLLOADMATRIXXOES>(gapic::GetGfxProcAddress("glLoadMatrixxOES", false));
        glLoadPaletteFromModelViewMatrixOES = reinterpret_cast<PFNGLLOADPALETTEFROMMODELVIEWMATRIXOES>(gapic::GetGfxProcAddress("glLoadPaletteFromModelViewMatrixOES", false));
        glLogicOp = reinterpret_cast<PFNGLLOGICOP>(gapic::GetGfxProcAddress("glLogicOp", false));
        glMaterialf = reinterpret_cast<PFNGLMATERIALF>(gapic::GetGfxProcAddress("glMaterialf", false));
        glMaterialfv = reinterpret_cast<PFNGLMATERIALFV>(gapic::GetGfxProcAddress("glMaterialfv", false));
        glMaterialx = reinterpret_cast<PFNGLMATERIALX>(gapic::GetGfxProcAddress("glMaterialx", false));
        glMaterialxOES = reinterpret_cast<PFNGLMATERIALXOES>(gapic::GetGfxProcAddress("glMaterialxOES", false));
        glMaterialxv = reinterpret_cast<PFNGLMATERIALXV>(gapic::GetGfxProcAddress("glMaterialxv", false));
        glMaterialxvOES = reinterpret_cast<PFNGLMATERIALXVOES>(gapic::GetGfxProcAddress("glMaterialxvOES", false));
        glMatrixIndexPointerOES = reinterpret_cast<PFNGLMATRIXINDEXPOINTEROES>(gapic::GetGfxProcAddress("glMatrixIndexPointerOES", false));
        glMatrixMode = reinterpret_cast<PFNGLMATRIXMODE>(gapic::GetGfxProcAddress("glMatrixMode", false));
        glMultMatrixf = reinterpret_cast<PFNGLMULTMATRIXF>(gapic::GetGfxProcAddress("glMultMatrixf", false));
        glMultMatrixx = reinterpret_cast<PFNGLMULTMATRIXX>(gapic::GetGfxProcAddress("glMultMatrixx", false));
        glMultMatrixxOES = reinterpret_cast<PFNGLMULTMATRIXXOES>(gapic::GetGfxProcAddress("glMultMatrixxOES", false));
        glMultiTexCoord4f = reinterpret_cast<PFNGLMULTITEXCOORD4F>(gapic::GetGfxProcAddress("glMultiTexCoord4f", false));
        glMultiTexCoord4x = reinterpret_cast<PFNGLMULTITEXCOORD4X>(gapic::GetGfxProcAddress("glMultiTexCoord4x", false));
        glMultiTexCoord4xOES = reinterpret_cast<PFNGLMULTITEXCOORD4XOES>(gapic::GetGfxProcAddress("glMultiTexCoord4xOES", false));
        glNormal3f = reinterpret_cast<PFNGLNORMAL3F>(gapic::GetGfxProcAddress("glNormal3f", false));
        glNormal3x = reinterpret_cast<PFNGLNORMAL3X>(gapic::GetGfxProcAddress("glNormal3x", false));
        glNormal3xOES = reinterpret_cast<PFNGLNORMAL3XOES>(gapic::GetGfxProcAddress("glNormal3xOES", false));
        glNormalPointer = reinterpret_cast<PFNGLNORMALPOINTER>(gapic::GetGfxProcAddress("glNormalPointer", false));
        glOrthof = reinterpret_cast<PFNGLORTHOF>(gapic::GetGfxProcAddress("glOrthof", false));
        glOrthofOES = reinterpret_cast<PFNGLORTHOFOES>(gapic::GetGfxProcAddress("glOrthofOES", false));
        glOrthox = reinterpret_cast<PFNGLORTHOX>(gapic::GetGfxProcAddress("glOrthox", false));
        glOrthoxOES = reinterpret_cast<PFNGLORTHOXOES>(gapic::GetGfxProcAddress("glOrthoxOES", false));
        glPointParameterf = reinterpret_cast<PFNGLPOINTPARAMETERF>(gapic::GetGfxProcAddress("glPointParameterf", false));
        glPointParameterfv = reinterpret_cast<PFNGLPOINTPARAMETERFV>(gapic::GetGfxProcAddress("glPointParameterfv", false));
        glPointParameterx = reinterpret_cast<PFNGLPOINTPARAMETERX>(gapic::GetGfxProcAddress("glPointParameterx", false));
        glPointParameterxOES = reinterpret_cast<PFNGLPOINTPARAMETERXOES>(gapic::GetGfxProcAddress("glPointParameterxOES", false));
        glPointParameterxv = reinterpret_cast<PFNGLPOINTPARAMETERXV>(gapic::GetGfxProcAddress("glPointParameterxv", false));
        glPointParameterxvOES = reinterpret_cast<PFNGLPOINTPARAMETERXVOES>(gapic::GetGfxProcAddress("glPointParameterxvOES", false));
        glPointSize = reinterpret_cast<PFNGLPOINTSIZE>(gapic::GetGfxProcAddress("glPointSize", false));
        glPointSizePointerOES = reinterpret_cast<PFNGLPOINTSIZEPOINTEROES>(gapic::GetGfxProcAddress("glPointSizePointerOES", false));
        glPointSizex = reinterpret_cast<PFNGLPOINTSIZEX>(gapic::GetGfxProcAddress("glPointSizex", false));
        glPointSizexOES = reinterpret_cast<PFNGLPOINTSIZEXOES>(gapic::GetGfxProcAddress("glPointSizexOES", false));
        glPolygonOffsetx = reinterpret_cast<PFNGLPOLYGONOFFSETX>(gapic::GetGfxProcAddress("glPolygonOffsetx", false));
        glPolygonOffsetxOES = reinterpret_cast<PFNGLPOLYGONOFFSETXOES>(gapic::GetGfxProcAddress("glPolygonOffsetxOES", false));
        glPopMatrix = reinterpret_cast<PFNGLPOPMATRIX>(gapic::GetGfxProcAddress("glPopMatrix", false));
        glPushMatrix = reinterpret_cast<PFNGLPUSHMATRIX>(gapic::GetGfxProcAddress("glPushMatrix", false));
        glQueryMatrixxOES = reinterpret_cast<PFNGLQUERYMATRIXXOES>(gapic::GetGfxProcAddress("glQueryMatrixxOES", false));
        glRenderbufferStorageOES = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEOES>(gapic::GetGfxProcAddress("glRenderbufferStorageOES", false));
        glRotatef = reinterpret_cast<PFNGLROTATEF>(gapic::GetGfxProcAddress("glRotatef", false));
        glRotatex = reinterpret_cast<PFNGLROTATEX>(gapic::GetGfxProcAddress("glRotatex", false));
        glRotatexOES = reinterpret_cast<PFNGLROTATEXOES>(gapic::GetGfxProcAddress("glRotatexOES", false));
        glSampleCoveragex = reinterpret_cast<PFNGLSAMPLECOVERAGEX>(gapic::GetGfxProcAddress("glSampleCoveragex", false));
        glSampleCoveragexOES = reinterpret_cast<PFNGLSAMPLECOVERAGEXOES>(gapic::GetGfxProcAddress("glSampleCoveragexOES", false));
        glScalef = reinterpret_cast<PFNGLSCALEF>(gapic::GetGfxProcAddress("glScalef", false));
        glScalex = reinterpret_cast<PFNGLSCALEX>(gapic::GetGfxProcAddress("glScalex", false));
        glScalexOES = reinterpret_cast<PFNGLSCALEXOES>(gapic::GetGfxProcAddress("glScalexOES", false));
        glShadeModel = reinterpret_cast<PFNGLSHADEMODEL>(gapic::GetGfxProcAddress("glShadeModel", false));
        glTexCoordPointer = reinterpret_cast<PFNGLTEXCOORDPOINTER>(gapic::GetGfxProcAddress("glTexCoordPointer", false));
        glTexEnvf = reinterpret_cast<PFNGLTEXENVF>(gapic::GetGfxProcAddress("glTexEnvf", false));
        glTexEnvfv = reinterpret_cast<PFNGLTEXENVFV>(gapic::GetGfxProcAddress("glTexEnvfv", false));
        glTexEnvi = reinterpret_cast<PFNGLTEXENVI>(gapic::GetGfxProcAddress("glTexEnvi", false));
        glTexEnviv = reinterpret_cast<PFNGLTEXENVIV>(gapic::GetGfxProcAddress("glTexEnviv", false));
        glTexEnvx = reinterpret_cast<PFNGLTEXENVX>(gapic::GetGfxProcAddress("glTexEnvx", false));
        glTexEnvxOES = reinterpret_cast<PFNGLTEXENVXOES>(gapic::GetGfxProcAddress("glTexEnvxOES", false));
        glTexEnvxv = reinterpret_cast<PFNGLTEXENVXV>(gapic::GetGfxProcAddress("glTexEnvxv", false));
        glTexEnvxvOES = reinterpret_cast<PFNGLTEXENVXVOES>(gapic::GetGfxProcAddress("glTexEnvxvOES", false));
        glTexGenfOES = reinterpret_cast<PFNGLTEXGENFOES>(gapic::GetGfxProcAddress("glTexGenfOES", false));
        glTexGenfvOES = reinterpret_cast<PFNGLTEXGENFVOES>(gapic::GetGfxProcAddress("glTexGenfvOES", false));
        glTexGeniOES = reinterpret_cast<PFNGLTEXGENIOES>(gapic::GetGfxProcAddress("glTexGeniOES", false));
        glTexGenivOES = reinterpret_cast<PFNGLTEXGENIVOES>(gapic::GetGfxProcAddress("glTexGenivOES", false));
        glTexGenxOES = reinterpret_cast<PFNGLTEXGENXOES>(gapic::GetGfxProcAddress("glTexGenxOES", false));
        glTexGenxvOES = reinterpret_cast<PFNGLTEXGENXVOES>(gapic::GetGfxProcAddress("glTexGenxvOES", false));
        glTexParameterx = reinterpret_cast<PFNGLTEXPARAMETERX>(gapic::GetGfxProcAddress("glTexParameterx", false));
        glTexParameterxOES = reinterpret_cast<PFNGLTEXPARAMETERXOES>(gapic::GetGfxProcAddress("glTexParameterxOES", false));
        glTexParameterxv = reinterpret_cast<PFNGLTEXPARAMETERXV>(gapic::GetGfxProcAddress("glTexParameterxv", false));
        glTexParameterxvOES = reinterpret_cast<PFNGLTEXPARAMETERXVOES>(gapic::GetGfxProcAddress("glTexParameterxvOES", false));
        glTranslatef = reinterpret_cast<PFNGLTRANSLATEF>(gapic::GetGfxProcAddress("glTranslatef", false));
        glTranslatex = reinterpret_cast<PFNGLTRANSLATEX>(gapic::GetGfxProcAddress("glTranslatex", false));
        glTranslatexOES = reinterpret_cast<PFNGLTRANSLATEXOES>(gapic::GetGfxProcAddress("glTranslatexOES", false));
        glVertexPointer = reinterpret_cast<PFNGLVERTEXPOINTER>(gapic::GetGfxProcAddress("glVertexPointer", false));
        glWeightPointerOES = reinterpret_cast<PFNGLWEIGHTPOINTEROES>(gapic::GetGfxProcAddress("glWeightPointerOES", false));
        glColorPointerBounds = reinterpret_cast<PFNGLCOLORPOINTERBOUNDS>(gapic::GetGfxProcAddress("glColorPointerBounds", false));
        glNormalPointerBounds = reinterpret_cast<PFNGLNORMALPOINTERBOUNDS>(gapic::GetGfxProcAddress("glNormalPointerBounds", false));
        glTexCoordPointerBounds = reinterpret_cast<PFNGLTEXCOORDPOINTERBOUNDS>(gapic::GetGfxProcAddress("glTexCoordPointerBounds", false));
        glVertexPointerBounds = reinterpret_cast<PFNGLVERTEXPOINTERBOUNDS>(gapic::GetGfxProcAddress("glVertexPointerBounds", false));
        glPointSizePointerOESBounds = reinterpret_cast<PFNGLPOINTSIZEPOINTEROESBOUNDS>(gapic::GetGfxProcAddress("glPointSizePointerOESBounds", false));
        glMatrixIndexPointerOESBounds = reinterpret_cast<PFNGLMATRIXINDEXPOINTEROESBOUNDS>(gapic::GetGfxProcAddress("glMatrixIndexPointerOESBounds", false));
        glWeightPointerOESBounds = reinterpret_cast<PFNGLWEIGHTPOINTEROESBOUNDS>(gapic::GetGfxProcAddress("glWeightPointerOESBounds", false));
    }

    const char* Gles::id() const {
        return ID;
    }

    bool Gles::callGlBlendBarrierKHR(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glBlendBarrierKHR()");
            if (glBlendBarrierKHR != nullptr) {
                glBlendBarrierKHR();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendBarrierKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendBarrierKHR");
            return false;
        }
    }

    bool Gles::callGlBlendEquationSeparateiEXT(Stack* stack, bool pushReturn) {
        auto modeAlpha = stack->pop<GLenum>();
        auto modeRGB = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationSeparateiEXT(%" PRIu32 ", %u, %u)", buf, modeRGB, modeAlpha);
            if (glBlendEquationSeparateiEXT != nullptr) {
                glBlendEquationSeparateiEXT(buf, modeRGB, modeAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparateiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationSeparateiEXT");
            return false;
        }
    }

    bool Gles::callGlBlendEquationiEXT(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationiEXT(%" PRIu32 ", %u)", buf, mode);
            if (glBlendEquationiEXT != nullptr) {
                glBlendEquationiEXT(buf, mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationiEXT");
            return false;
        }
    }

    bool Gles::callGlBlendFuncSeparateiEXT(Stack* stack, bool pushReturn) {
        auto dstAlpha = stack->pop<GLenum>();
        auto srcAlpha = stack->pop<GLenum>();
        auto dstRGB = stack->pop<GLenum>();
        auto srcRGB = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFuncSeparateiEXT(%" PRIu32 ", %u, %u, %u, %u)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
            if (glBlendFuncSeparateiEXT != nullptr) {
                glBlendFuncSeparateiEXT(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparateiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFuncSeparateiEXT");
            return false;
        }
    }

    bool Gles::callGlBlendFunciEXT(Stack* stack, bool pushReturn) {
        auto dst = stack->pop<GLenum>();
        auto src = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFunciEXT(%" PRIu32 ", %u, %u)", buf, src, dst);
            if (glBlendFunciEXT != nullptr) {
                glBlendFunciEXT(buf, src, dst);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFunciEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFunciEXT");
            return false;
        }
    }

    bool Gles::callGlColorMaskiEXT(Stack* stack, bool pushReturn) {
        auto a = stack->pop<uint8_t>();
        auto b = stack->pop<uint8_t>();
        auto g = stack->pop<uint8_t>();
        auto r = stack->pop<uint8_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColorMaskiEXT(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", index, r, g, b, a);
            if (glColorMaskiEXT != nullptr) {
                glColorMaskiEXT(index, r, g, b, a);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColorMaskiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColorMaskiEXT");
            return false;
        }
    }

    bool Gles::callGlCopyImageSubDataEXT(Stack* stack, bool pushReturn) {
        auto srcDepth = stack->pop<int32_t>();
        auto srcHeight = stack->pop<int32_t>();
        auto srcWidth = stack->pop<int32_t>();
        auto dstZ = stack->pop<int32_t>();
        auto dstY = stack->pop<int32_t>();
        auto dstX = stack->pop<int32_t>();
        auto dstLevel = stack->pop<int32_t>();
        auto dstTarget = stack->pop<GLenum>();
        auto dstName = stack->pop<uint32_t>();
        auto srcZ = stack->pop<int32_t>();
        auto srcY = stack->pop<int32_t>();
        auto srcX = stack->pop<int32_t>();
        auto srcLevel = stack->pop<int32_t>();
        auto srcTarget = stack->pop<GLenum>();
        auto srcName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("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 (glCopyImageSubDataEXT != nullptr) {
                glCopyImageSubDataEXT(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyImageSubDataEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyImageSubDataEXT");
            return false;
        }
    }

    bool Gles::callGlDebugMessageCallbackKHR(Stack* stack, bool pushReturn) {
        auto userParam = stack->pop<void*>();
        auto callback = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glDebugMessageCallbackKHR(%p, %p)", callback, userParam);
            if (glDebugMessageCallbackKHR != nullptr) {
                glDebugMessageCallbackKHR(callback, userParam);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDebugMessageCallbackKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDebugMessageCallbackKHR");
            return false;
        }
    }

    bool Gles::callGlDebugMessageControlKHR(Stack* stack, bool pushReturn) {
        auto enabled = stack->pop<uint8_t>();
        auto ids = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto severity = stack->pop<GLenum>();
        auto type = stack->pop<GLenum>();
        auto source = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDebugMessageControlKHR(%u, %u, %u, %" PRId32 ", %p, %" PRIu8 ")", source, type, severity, count, ids, enabled);
            if (glDebugMessageControlKHR != nullptr) {
                glDebugMessageControlKHR(source, type, severity, count, ids, enabled);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDebugMessageControlKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDebugMessageControlKHR");
            return false;
        }
    }

    bool Gles::callGlDebugMessageInsertKHR(Stack* stack, bool pushReturn) {
        auto message = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto severity = stack->pop<GLenum>();
        auto id = stack->pop<uint32_t>();
        auto type = stack->pop<GLenum>();
        auto source = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDebugMessageInsertKHR(%u, %u, %" PRIu32 ", %u, %" PRId32 ", %p)", source, type, id, severity, length, message);
            if (glDebugMessageInsertKHR != nullptr) {
                glDebugMessageInsertKHR(source, type, id, severity, length, message);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDebugMessageInsertKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDebugMessageInsertKHR");
            return false;
        }
    }

    bool Gles::callGlDisableiEXT(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDisableiEXT(%u, %" PRIu32 ")", target, index);
            if (glDisableiEXT != nullptr) {
                glDisableiEXT(target, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisableiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisableiEXT");
            return false;
        }
    }

    bool Gles::callGlEnableiEXT(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEnableiEXT(%u, %" PRIu32 ")", target, index);
            if (glEnableiEXT != nullptr) {
                glEnableiEXT(target, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnableiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnableiEXT");
            return false;
        }
    }

    bool Gles::callGlFramebufferTextureEXT(Stack* stack, bool pushReturn) {
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTextureEXT(%u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, texture, level);
            if (glFramebufferTextureEXT != nullptr) {
                glFramebufferTextureEXT(target, attachment, texture, level);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTextureEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTextureEXT");
            return false;
        }
    }

    bool Gles::callGlGetDebugMessageLogKHR(Stack* stack, bool pushReturn) {
        auto messageLog = stack->pop<GLchar*>();
        auto lengths = stack->pop<GLsizei*>();
        auto severities = stack->pop<GLenum*>();
        auto ids = stack->pop<GLuint*>();
        auto types = stack->pop<GLenum*>();
        auto sources = stack->pop<GLenum*>();
        auto bufSize = stack->pop<int32_t>();
        auto count = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetDebugMessageLogKHR(%" PRIu32 ", %" PRId32 ", %p, %p, %p, %p, %p, %p)", count, bufSize, sources, types, ids, severities, lengths, messageLog);
            if (glGetDebugMessageLogKHR != nullptr) {
                GLuint return_value = glGetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths, messageLog);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetDebugMessageLogKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetDebugMessageLogKHR");
            return false;
        }
    }

    bool Gles::callGlGetObjectLabelKHR(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto name = stack->pop<uint32_t>();
        auto identifier = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetObjectLabelKHR(%u, %" PRIu32 ", %" PRId32 ", %p, %p)", identifier, name, bufSize, length, label);
            if (glGetObjectLabelKHR != nullptr) {
                glGetObjectLabelKHR(identifier, name, bufSize, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetObjectLabelKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetObjectLabelKHR");
            return false;
        }
    }

    bool Gles::callGlGetObjectPtrLabelKHR(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto ptr = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetObjectPtrLabelKHR(%p, %" PRId32 ", %p, %p)", ptr, bufSize, length, label);
            if (glGetObjectPtrLabelKHR != nullptr) {
                glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetObjectPtrLabelKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetObjectPtrLabelKHR");
            return false;
        }
    }

    bool Gles::callGlGetPointervKHR(Stack* stack, bool pushReturn) {
        auto params = stack->pop<void**>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPointervKHR(%u, %p)", pname, params);
            if (glGetPointervKHR != nullptr) {
                glGetPointervKHR(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPointervKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPointervKHR");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterIivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterIivEXT(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterIivEXT != nullptr) {
                glGetSamplerParameterIivEXT(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterIivEXT");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterIuivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterIuivEXT(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterIuivEXT != nullptr) {
                glGetSamplerParameterIuivEXT(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIuivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterIuivEXT");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterIivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterIivEXT(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterIivEXT != nullptr) {
                glGetTexParameterIivEXT(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterIivEXT");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterIuivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterIuivEXT(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterIuivEXT != nullptr) {
                glGetTexParameterIuivEXT(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIuivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterIuivEXT");
            return false;
        }
    }

    bool Gles::callGlIsEnablediEXT(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glIsEnablediEXT(%u, %" PRIu32 ")", target, index);
            if (glIsEnablediEXT != nullptr) {
                GLboolean return_value = glIsEnablediEXT(target, index);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsEnablediEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsEnablediEXT");
            return false;
        }
    }

    bool Gles::callGlMinSampleShadingOES(Stack* stack, bool pushReturn) {
        auto value = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glMinSampleShadingOES(%f)", value);
            if (glMinSampleShadingOES != nullptr) {
                glMinSampleShadingOES(value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMinSampleShadingOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMinSampleShadingOES");
            return false;
        }
    }

    bool Gles::callGlObjectLabelKHR(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto name = stack->pop<uint32_t>();
        auto identifier = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glObjectLabelKHR(%u, %" PRIu32 ", %" PRId32 ", %p)", identifier, name, length, label);
            if (glObjectLabelKHR != nullptr) {
                glObjectLabelKHR(identifier, name, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glObjectLabelKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glObjectLabelKHR");
            return false;
        }
    }

    bool Gles::callGlObjectPtrLabelKHR(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto ptr = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glObjectPtrLabelKHR(%p, %" PRId32 ", %p)", ptr, length, label);
            if (glObjectPtrLabelKHR != nullptr) {
                glObjectPtrLabelKHR(ptr, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glObjectPtrLabelKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glObjectPtrLabelKHR");
            return false;
        }
    }

    bool Gles::callGlPatchParameteriEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPatchParameteriEXT(%u, %" PRId32 ")", pname, value);
            if (glPatchParameteriEXT != nullptr) {
                glPatchParameteriEXT(pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPatchParameteriEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPatchParameteriEXT");
            return false;
        }
    }

    bool Gles::callGlPopDebugGroupKHR(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glPopDebugGroupKHR()");
            if (glPopDebugGroupKHR != nullptr) {
                glPopDebugGroupKHR();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPopDebugGroupKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPopDebugGroupKHR");
            return false;
        }
    }

    bool Gles::callGlPrimitiveBoundingBoxEXT(Stack* stack, bool pushReturn) {
        auto maxW = stack->pop<float>();
        auto maxZ = stack->pop<float>();
        auto maxY = stack->pop<float>();
        auto maxX = stack->pop<float>();
        auto minW = stack->pop<float>();
        auto minZ = stack->pop<float>();
        auto minY = stack->pop<float>();
        auto minX = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glPrimitiveBoundingBoxEXT(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            if (glPrimitiveBoundingBoxEXT != nullptr) {
                glPrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPrimitiveBoundingBoxEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPrimitiveBoundingBoxEXT");
            return false;
        }
    }

    bool Gles::callGlPushDebugGroupKHR(Stack* stack, bool pushReturn) {
        auto message = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto id = stack->pop<uint32_t>();
        auto source = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPushDebugGroupKHR(%u, %" PRIu32 ", %" PRId32 ", %p)", source, id, length, message);
            if (glPushDebugGroupKHR != nullptr) {
                glPushDebugGroupKHR(source, id, length, message);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPushDebugGroupKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPushDebugGroupKHR");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterIivEXT(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterIivEXT(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterIivEXT != nullptr) {
                glSamplerParameterIivEXT(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterIivEXT");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterIuivEXT(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterIuivEXT(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterIuivEXT != nullptr) {
                glSamplerParameterIuivEXT(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIuivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterIuivEXT");
            return false;
        }
    }

    bool Gles::callGlTexBufferEXT(Stack* stack, bool pushReturn) {
        auto buffer = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexBufferEXT(%u, %u, %" PRIu32 ")", target, internalformat, buffer);
            if (glTexBufferEXT != nullptr) {
                glTexBufferEXT(target, internalformat, buffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexBufferEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexBufferEXT");
            return false;
        }
    }

    bool Gles::callGlTexBufferRangeEXT(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto buffer = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexBufferRangeEXT(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, internalformat, buffer, offset, size);
            if (glTexBufferRangeEXT != nullptr) {
                glTexBufferRangeEXT(target, internalformat, buffer, offset, size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexBufferRangeEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexBufferRangeEXT");
            return false;
        }
    }

    bool Gles::callGlTexParameterIivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterIivEXT(%u, %u, %p)", target, pname, params);
            if (glTexParameterIivEXT != nullptr) {
                glTexParameterIivEXT(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterIivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterIivEXT");
            return false;
        }
    }

    bool Gles::callGlTexParameterIuivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterIuivEXT(%u, %u, %p)", target, pname, params);
            if (glTexParameterIuivEXT != nullptr) {
                glTexParameterIuivEXT(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterIuivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterIuivEXT");
            return false;
        }
    }

    bool Gles::callGlTexStorage3DMultisampleOES(Stack* stack, bool pushReturn) {
        auto fixedsamplelocations = stack->pop<uint8_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage3DMultisampleOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, samples, internalformat, width, height, depth, fixedsamplelocations);
            if (glTexStorage3DMultisampleOES != nullptr) {
                glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, fixedsamplelocations);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage3DMultisampleOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage3DMultisampleOES");
            return false;
        }
    }

    bool Gles::callGlBeginQuery(Stack* stack, bool pushReturn) {
        auto query = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBeginQuery(%u, %" PRIu32 ")", target, query);
            if (glBeginQuery != nullptr) {
                glBeginQuery(target, query);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBeginQuery");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBeginQuery");
            return false;
        }
    }

    bool Gles::callGlDeleteQueries(Stack* stack, bool pushReturn) {
        auto queries = stack->pop<QueryId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteQueries(%" PRId32 ", %p)", count, queries);
            if (glDeleteQueries != nullptr) {
                glDeleteQueries(count, queries);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteQueries");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteQueries");
            return false;
        }
    }

    bool Gles::callGlEndQuery(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEndQuery(%u)", target);
            if (glEndQuery != nullptr) {
                glEndQuery(target);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndQuery");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndQuery");
            return false;
        }
    }

    bool Gles::callGlGenQueries(Stack* stack, bool pushReturn) {
        auto queries = stack->pop<QueryId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenQueries(%" PRId32 ", %p)", count, queries);
            if (glGenQueries != nullptr) {
                glGenQueries(count, queries);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenQueries");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenQueries");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjectuiv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjectuiv(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjectuiv != nullptr) {
                glGetQueryObjectuiv(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjectuiv");
            return false;
        }
    }

    bool Gles::callGlGetQueryiv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryiv(%u, %u, %p)", target, parameter, value);
            if (glGetQueryiv != nullptr) {
                glGetQueryiv(target, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryiv");
            return false;
        }
    }

    bool Gles::callGlIsQuery(Stack* stack, bool pushReturn) {
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsQuery(%" PRIu32 ")", query);
            if (glIsQuery != nullptr) {
                GLboolean return_value = glIsQuery(query);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsQuery");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsQuery");
            return false;
        }
    }

    bool Gles::callGlBindBuffer(Stack* stack, bool pushReturn) {
        auto buffer = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindBuffer(%u, %" PRIu32 ")", target, buffer);
            if (glBindBuffer != nullptr) {
                glBindBuffer(target, buffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindBuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindBuffer");
            return false;
        }
    }

    bool Gles::callGlBindBufferBase(Stack* stack, bool pushReturn) {
        auto buffer = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindBufferBase(%u, %" PRIu32 ", %" PRIu32 ")", target, index, buffer);
            if (glBindBufferBase != nullptr) {
                glBindBufferBase(target, index, buffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindBufferBase");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindBufferBase");
            return false;
        }
    }

    bool Gles::callGlBindBufferRange(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto buffer = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindBufferRange(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, index, buffer, offset, size);
            if (glBindBufferRange != nullptr) {
                glBindBufferRange(target, index, buffer, offset, size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindBufferRange");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindBufferRange");
            return false;
        }
    }

    bool Gles::callGlBufferData(Stack* stack, bool pushReturn) {
        auto usage = stack->pop<GLenum>();
        auto data = stack->pop<void*>();
        auto size = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBufferData(%u, %" PRId32 ", %p, %u)", target, size, data, usage);
            if (glBufferData != nullptr) {
                glBufferData(target, size, data, usage);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBufferData");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBufferData");
            return false;
        }
    }

    bool Gles::callGlBufferSubData(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto size = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBufferSubData(%u, %" PRId32 ", %" PRId32 ", %p)", target, offset, size, data);
            if (glBufferSubData != nullptr) {
                glBufferSubData(target, offset, size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBufferSubData");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBufferSubData");
            return false;
        }
    }

    bool Gles::callGlCopyBufferSubData(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        auto writeOffset = stack->pop<int32_t>();
        auto readOffset = stack->pop<int32_t>();
        auto writeTarget = stack->pop<GLenum>();
        auto readTarget = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyBufferSubData(%u, %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", readTarget, writeTarget, readOffset, writeOffset, size);
            if (glCopyBufferSubData != nullptr) {
                glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyBufferSubData");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyBufferSubData");
            return false;
        }
    }

    bool Gles::callGlDeleteBuffers(Stack* stack, bool pushReturn) {
        auto buffers = stack->pop<BufferId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteBuffers(%" PRId32 ", %p)", count, buffers);
            if (glDeleteBuffers != nullptr) {
                glDeleteBuffers(count, buffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteBuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteBuffers");
            return false;
        }
    }

    bool Gles::callGlGenBuffers(Stack* stack, bool pushReturn) {
        auto buffers = stack->pop<BufferId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenBuffers(%" PRId32 ", %p)", count, buffers);
            if (glGenBuffers != nullptr) {
                glGenBuffers(count, buffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenBuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenBuffers");
            return false;
        }
    }

    bool Gles::callGlGetBufferParameteri64v(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint64*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetBufferParameteri64v(%u, %u, %p)", target, parameter, value);
            if (glGetBufferParameteri64v != nullptr) {
                glGetBufferParameteri64v(target, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetBufferParameteri64v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetBufferParameteri64v");
            return false;
        }
    }

    bool Gles::callGlGetBufferParameteriv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetBufferParameteriv(%u, %u, %p)", target, parameter, value);
            if (glGetBufferParameteriv != nullptr) {
                glGetBufferParameteriv(target, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetBufferParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetBufferParameteriv");
            return false;
        }
    }

    bool Gles::callGlGetBufferPointerv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<void**>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetBufferPointerv(%u, %u, %p)", target, pname, params);
            if (glGetBufferPointerv != nullptr) {
                glGetBufferPointerv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetBufferPointerv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetBufferPointerv");
            return false;
        }
    }

    bool Gles::callGlIsBuffer(Stack* stack, bool pushReturn) {
        auto buffer = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsBuffer(%" PRIu32 ")", buffer);
            if (glIsBuffer != nullptr) {
                GLboolean return_value = glIsBuffer(buffer);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsBuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsBuffer");
            return false;
        }
    }

    bool Gles::callGlMapBufferRange(Stack* stack, bool pushReturn) {
        auto access = stack->pop<GLbitfield>();
        auto length = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMapBufferRange(%u, %" PRId32 ", %" PRId32 ", %u)", target, offset, length, access);
            if (glMapBufferRange != nullptr) {
                void* return_value = glMapBufferRange(target, offset, length, access);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<void*>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMapBufferRange");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMapBufferRange");
            return false;
        }
    }

    bool Gles::callGlUnmapBuffer(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glUnmapBuffer(%u)", target);
            if (glUnmapBuffer != nullptr) {
                GLboolean return_value = glUnmapBuffer(target);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUnmapBuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUnmapBuffer");
            return false;
        }
    }

    bool Gles::callGlDebugMessageCallback(Stack* stack, bool pushReturn) {
        auto userParam = stack->pop<void*>();
        auto callback = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glDebugMessageCallback(%p, %p)", callback, userParam);
            if (glDebugMessageCallback != nullptr) {
                glDebugMessageCallback(callback, userParam);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDebugMessageCallback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDebugMessageCallback");
            return false;
        }
    }

    bool Gles::callGlDebugMessageControl(Stack* stack, bool pushReturn) {
        auto enabled = stack->pop<uint8_t>();
        auto ids = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto severity = stack->pop<GLenum>();
        auto type = stack->pop<GLenum>();
        auto source = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDebugMessageControl(%u, %u, %u, %" PRId32 ", %p, %" PRIu8 ")", source, type, severity, count, ids, enabled);
            if (glDebugMessageControl != nullptr) {
                glDebugMessageControl(source, type, severity, count, ids, enabled);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDebugMessageControl");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDebugMessageControl");
            return false;
        }
    }

    bool Gles::callGlDebugMessageInsert(Stack* stack, bool pushReturn) {
        auto message = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto severity = stack->pop<GLenum>();
        auto id = stack->pop<uint32_t>();
        auto type = stack->pop<GLenum>();
        auto source = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDebugMessageInsert(%u, %u, %" PRIu32 ", %u, %" PRId32 ", %p)", source, type, id, severity, length, message);
            if (glDebugMessageInsert != nullptr) {
                glDebugMessageInsert(source, type, id, severity, length, message);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDebugMessageInsert");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDebugMessageInsert");
            return false;
        }
    }

    bool Gles::callGlGetDebugMessageLog(Stack* stack, bool pushReturn) {
        auto messageLog = stack->pop<GLchar*>();
        auto lengths = stack->pop<GLsizei*>();
        auto severities = stack->pop<GLenum*>();
        auto ids = stack->pop<GLuint*>();
        auto types = stack->pop<GLenum*>();
        auto sources = stack->pop<GLenum*>();
        auto bufSize = stack->pop<int32_t>();
        auto count = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetDebugMessageLog(%" PRIu32 ", %" PRId32 ", %p, %p, %p, %p, %p, %p)", count, bufSize, sources, types, ids, severities, lengths, messageLog);
            if (glGetDebugMessageLog != nullptr) {
                GLuint return_value = glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetDebugMessageLog");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetDebugMessageLog");
            return false;
        }
    }

    bool Gles::callGlGetObjectLabel(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto name = stack->pop<uint32_t>();
        auto identifier = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetObjectLabel(%u, %" PRIu32 ", %" PRId32 ", %p, %p)", identifier, name, bufSize, length, label);
            if (glGetObjectLabel != nullptr) {
                glGetObjectLabel(identifier, name, bufSize, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetObjectLabel");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetObjectLabel");
            return false;
        }
    }

    bool Gles::callGlGetObjectPtrLabel(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto ptr = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetObjectPtrLabel(%p, %" PRId32 ", %p, %p)", ptr, bufSize, length, label);
            if (glGetObjectPtrLabel != nullptr) {
                glGetObjectPtrLabel(ptr, bufSize, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetObjectPtrLabel");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetObjectPtrLabel");
            return false;
        }
    }

    bool Gles::callGlGetPointerv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<void**>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPointerv(%u, %p)", pname, params);
            if (glGetPointerv != nullptr) {
                glGetPointerv(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPointerv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPointerv");
            return false;
        }
    }

    bool Gles::callGlObjectLabel(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto name = stack->pop<uint32_t>();
        auto identifier = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glObjectLabel(%u, %" PRIu32 ", %" PRId32 ", %p)", identifier, name, length, label);
            if (glObjectLabel != nullptr) {
                glObjectLabel(identifier, name, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glObjectLabel");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glObjectLabel");
            return false;
        }
    }

    bool Gles::callGlObjectPtrLabel(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto ptr = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glObjectPtrLabel(%p, %" PRId32 ", %p)", ptr, length, label);
            if (glObjectPtrLabel != nullptr) {
                glObjectPtrLabel(ptr, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glObjectPtrLabel");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glObjectPtrLabel");
            return false;
        }
    }

    bool Gles::callGlPopDebugGroup(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glPopDebugGroup()");
            if (glPopDebugGroup != nullptr) {
                glPopDebugGroup();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPopDebugGroup");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPopDebugGroup");
            return false;
        }
    }

    bool Gles::callGlPushDebugGroup(Stack* stack, bool pushReturn) {
        auto message = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto id = stack->pop<uint32_t>();
        auto source = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPushDebugGroup(%u, %" PRIu32 ", %" PRId32 ", %p)", source, id, length, message);
            if (glPushDebugGroup != nullptr) {
                glPushDebugGroup(source, id, length, message);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPushDebugGroup");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPushDebugGroup");
            return false;
        }
    }

    bool Gles::callGlDrawArrays(Stack* stack, bool pushReturn) {
        auto indices_count = stack->pop<int32_t>();
        auto first_index = stack->pop<int32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArrays(%u, %" PRId32 ", %" PRId32 ")", draw_mode, first_index, indices_count);
            if (glDrawArrays != nullptr) {
                glDrawArrays(draw_mode, first_index, indices_count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArrays");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArrays");
            return false;
        }
    }

    bool Gles::callGlDrawArraysIndirect(Stack* stack, bool pushReturn) {
        auto indirect = stack->pop<void*>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArraysIndirect(%u, %p)", draw_mode, indirect);
            if (glDrawArraysIndirect != nullptr) {
                glDrawArraysIndirect(draw_mode, indirect);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArraysIndirect");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArraysIndirect");
            return false;
        }
    }

    bool Gles::callGlDrawArraysInstanced(Stack* stack, bool pushReturn) {
        auto instance_count = stack->pop<int32_t>();
        auto indices_count = stack->pop<int32_t>();
        auto first_index = stack->pop<int32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArraysInstanced(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", draw_mode, first_index, indices_count, instance_count);
            if (glDrawArraysInstanced != nullptr) {
                glDrawArraysInstanced(draw_mode, first_index, indices_count, instance_count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstanced");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArraysInstanced");
            return false;
        }
    }

    bool Gles::callGlDrawElements(Stack* stack, bool pushReturn) {
        auto indices = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto indices_count = stack->pop<int32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElements(%u, %" PRId32 ", %u, %p)", draw_mode, indices_count, indices_type, indices);
            if (glDrawElements != nullptr) {
                glDrawElements(draw_mode, indices_count, indices_type, indices);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElements");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElements");
            return false;
        }
    }

    bool Gles::callGlDrawElementsBaseVertex(Stack* stack, bool pushReturn) {
        auto base_vertex = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto indices_count = stack->pop<int32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsBaseVertex(%u, %" PRId32 ", %u, %p, %" PRId32 ")", draw_mode, indices_count, indices_type, indices, base_vertex);
            if (glDrawElementsBaseVertex != nullptr) {
                glDrawElementsBaseVertex(draw_mode, indices_count, indices_type, indices, base_vertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsBaseVertex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsBaseVertex");
            return false;
        }
    }

    bool Gles::callGlDrawElementsIndirect(Stack* stack, bool pushReturn) {
        auto indirect = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsIndirect(%u, %u, %p)", draw_mode, indices_type, indirect);
            if (glDrawElementsIndirect != nullptr) {
                glDrawElementsIndirect(draw_mode, indices_type, indirect);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsIndirect");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsIndirect");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstanced(Stack* stack, bool pushReturn) {
        auto instance_count = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto indices_count = stack->pop<int32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstanced(%u, %" PRId32 ", %u, %p, %" PRId32 ")", draw_mode, indices_count, indices_type, indices, instance_count);
            if (glDrawElementsInstanced != nullptr) {
                glDrawElementsInstanced(draw_mode, indices_count, indices_type, indices, instance_count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstanced");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstanced");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedBaseVertex(Stack* stack, bool pushReturn) {
        auto base_vertex = stack->pop<int32_t>();
        auto instance_count = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto indices_count = stack->pop<int32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedBaseVertex(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ")", draw_mode, indices_count, indices_type, indices, instance_count, base_vertex);
            if (glDrawElementsInstancedBaseVertex != nullptr) {
                glDrawElementsInstancedBaseVertex(draw_mode, indices_count, indices_type, indices, instance_count, base_vertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedBaseVertex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedBaseVertex");
            return false;
        }
    }

    bool Gles::callGlDrawRangeElements(Stack* stack, bool pushReturn) {
        auto indices = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto indices_count = stack->pop<int32_t>();
        auto end = stack->pop<uint32_t>();
        auto start = stack->pop<uint32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawRangeElements(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p)", draw_mode, start, end, indices_count, indices_type, indices);
            if (glDrawRangeElements != nullptr) {
                glDrawRangeElements(draw_mode, start, end, indices_count, indices_type, indices);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawRangeElements");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawRangeElements");
            return false;
        }
    }

    bool Gles::callGlDrawRangeElementsBaseVertex(Stack* stack, bool pushReturn) {
        auto base_vertex = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto indices_type = stack->pop<GLenum>();
        auto indices_count = stack->pop<int32_t>();
        auto end = stack->pop<uint32_t>();
        auto start = stack->pop<uint32_t>();
        auto draw_mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawRangeElementsBaseVertex(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p, %" PRId32 ")", draw_mode, start, end, indices_count, indices_type, indices, base_vertex);
            if (glDrawRangeElementsBaseVertex != nullptr) {
                glDrawRangeElementsBaseVertex(draw_mode, start, end, indices_count, indices_type, indices, base_vertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawRangeElementsBaseVertex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawRangeElementsBaseVertex");
            return false;
        }
    }

    bool Gles::callGlPatchParameteri(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPatchParameteri(%u, %" PRId32 ")", pname, value);
            if (glPatchParameteri != nullptr) {
                glPatchParameteri(pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPatchParameteri");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPatchParameteri");
            return false;
        }
    }

    bool Gles::callGlPrimitiveBoundingBox(Stack* stack, bool pushReturn) {
        auto maxW = stack->pop<float>();
        auto maxZ = stack->pop<float>();
        auto maxY = stack->pop<float>();
        auto maxX = stack->pop<float>();
        auto minW = stack->pop<float>();
        auto minZ = stack->pop<float>();
        auto minY = stack->pop<float>();
        auto minX = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glPrimitiveBoundingBox(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            if (glPrimitiveBoundingBox != nullptr) {
                glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPrimitiveBoundingBox");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPrimitiveBoundingBox");
            return false;
        }
    }

    bool Gles::callGlActiveShaderProgramEXT(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glActiveShaderProgramEXT(%" PRIu32 ", %" PRIu32 ")", pipeline, program);
            if (glActiveShaderProgramEXT != nullptr) {
                glActiveShaderProgramEXT(pipeline, program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glActiveShaderProgramEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glActiveShaderProgramEXT");
            return false;
        }
    }

    bool Gles::callGlAlphaFuncQCOM(Stack* stack, bool pushReturn) {
        auto ref = stack->pop<float>();
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glAlphaFuncQCOM(%u, %f)", func, ref);
            if (glAlphaFuncQCOM != nullptr) {
                glAlphaFuncQCOM(func, ref);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glAlphaFuncQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glAlphaFuncQCOM");
            return false;
        }
    }

    bool Gles::callGlApplyFramebufferAttachmentCMAAINTEL(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glApplyFramebufferAttachmentCMAAINTEL()");
            if (glApplyFramebufferAttachmentCMAAINTEL != nullptr) {
                glApplyFramebufferAttachmentCMAAINTEL();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glApplyFramebufferAttachmentCMAAINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glApplyFramebufferAttachmentCMAAINTEL");
            return false;
        }
    }

    bool Gles::callGlBeginConditionalRenderNV(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        auto id = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBeginConditionalRenderNV(%" PRIu32 ", %u)", id, mode);
            if (glBeginConditionalRenderNV != nullptr) {
                glBeginConditionalRenderNV(id, mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBeginConditionalRenderNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBeginConditionalRenderNV");
            return false;
        }
    }

    bool Gles::callGlBeginPerfMonitorAMD(Stack* stack, bool pushReturn) {
        auto monitor = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBeginPerfMonitorAMD(%" PRIu32 ")", monitor);
            if (glBeginPerfMonitorAMD != nullptr) {
                glBeginPerfMonitorAMD(monitor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBeginPerfMonitorAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBeginPerfMonitorAMD");
            return false;
        }
    }

    bool Gles::callGlBeginPerfQueryINTEL(Stack* stack, bool pushReturn) {
        auto queryHandle = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBeginPerfQueryINTEL(%" PRIu32 ")", queryHandle);
            if (glBeginPerfQueryINTEL != nullptr) {
                glBeginPerfQueryINTEL(queryHandle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBeginPerfQueryINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBeginPerfQueryINTEL");
            return false;
        }
    }

    bool Gles::callGlBeginQueryEXT(Stack* stack, bool pushReturn) {
        auto query = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBeginQueryEXT(%u, %" PRIu32 ")", target, query);
            if (glBeginQueryEXT != nullptr) {
                glBeginQueryEXT(target, query);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBeginQueryEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBeginQueryEXT");
            return false;
        }
    }

    bool Gles::callGlBindFragDataLocationEXT(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto color = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindFragDataLocationEXT(%" PRIu32 ", %" PRIu32 ", %s)", program, color, name);
            if (glBindFragDataLocationEXT != nullptr) {
                glBindFragDataLocationEXT(program, color, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindFragDataLocationEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindFragDataLocationEXT");
            return false;
        }
    }

    bool Gles::callGlBindFragDataLocationIndexedEXT(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto index = stack->pop<uint32_t>();
        auto colorNumber = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindFragDataLocationIndexedEXT(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %s)", program, colorNumber, index, name);
            if (glBindFragDataLocationIndexedEXT != nullptr) {
                glBindFragDataLocationIndexedEXT(program, colorNumber, index, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindFragDataLocationIndexedEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindFragDataLocationIndexedEXT");
            return false;
        }
    }

    bool Gles::callGlBindProgramPipelineEXT(Stack* stack, bool pushReturn) {
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindProgramPipelineEXT(%" PRIu32 ")", pipeline);
            if (glBindProgramPipelineEXT != nullptr) {
                glBindProgramPipelineEXT(pipeline);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindProgramPipelineEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindProgramPipelineEXT");
            return false;
        }
    }

    bool Gles::callGlBindVertexArrayOES(Stack* stack, bool pushReturn) {
        auto array = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindVertexArrayOES(%" PRIu32 ")", array);
            if (glBindVertexArrayOES != nullptr) {
                glBindVertexArrayOES(array);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindVertexArrayOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindVertexArrayOES");
            return false;
        }
    }

    bool Gles::callGlBlendBarrierNV(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glBlendBarrierNV()");
            if (glBlendBarrierNV != nullptr) {
                glBlendBarrierNV();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendBarrierNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendBarrierNV");
            return false;
        }
    }

    bool Gles::callGlBlendEquationSeparateiOES(Stack* stack, bool pushReturn) {
        auto modeAlpha = stack->pop<GLenum>();
        auto modeRGB = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationSeparateiOES(%" PRIu32 ", %u, %u)", buf, modeRGB, modeAlpha);
            if (glBlendEquationSeparateiOES != nullptr) {
                glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparateiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationSeparateiOES");
            return false;
        }
    }

    bool Gles::callGlBlendEquationiOES(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationiOES(%" PRIu32 ", %u)", buf, mode);
            if (glBlendEquationiOES != nullptr) {
                glBlendEquationiOES(buf, mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationiOES");
            return false;
        }
    }

    bool Gles::callGlBlendFuncSeparateiOES(Stack* stack, bool pushReturn) {
        auto dstAlpha = stack->pop<GLenum>();
        auto srcAlpha = stack->pop<GLenum>();
        auto dstRGB = stack->pop<GLenum>();
        auto srcRGB = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFuncSeparateiOES(%" PRIu32 ", %u, %u, %u, %u)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
            if (glBlendFuncSeparateiOES != nullptr) {
                glBlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparateiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFuncSeparateiOES");
            return false;
        }
    }

    bool Gles::callGlBlendFunciOES(Stack* stack, bool pushReturn) {
        auto dst = stack->pop<GLenum>();
        auto src = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFunciOES(%" PRIu32 ", %u, %u)", buf, src, dst);
            if (glBlendFunciOES != nullptr) {
                glBlendFunciOES(buf, src, dst);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFunciOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFunciOES");
            return false;
        }
    }

    bool Gles::callGlBlendParameteriNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendParameteriNV(%u, %" PRId32 ")", pname, value);
            if (glBlendParameteriNV != nullptr) {
                glBlendParameteriNV(pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendParameteriNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendParameteriNV");
            return false;
        }
    }

    bool Gles::callGlBlitFramebufferANGLE(Stack* stack, bool pushReturn) {
        auto filter = stack->pop<GLenum>();
        auto mask = stack->pop<GLbitfield>();
        auto dstY1 = stack->pop<int32_t>();
        auto dstX1 = stack->pop<int32_t>();
        auto dstY0 = stack->pop<int32_t>();
        auto dstX0 = stack->pop<int32_t>();
        auto srcY1 = stack->pop<int32_t>();
        auto srcX1 = stack->pop<int32_t>();
        auto srcY0 = stack->pop<int32_t>();
        auto srcX0 = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlitFramebufferANGLE(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
            if (glBlitFramebufferANGLE != nullptr) {
                glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlitFramebufferANGLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlitFramebufferANGLE");
            return false;
        }
    }

    bool Gles::callGlBlitFramebufferNV(Stack* stack, bool pushReturn) {
        auto filter = stack->pop<GLenum>();
        auto mask = stack->pop<GLbitfield>();
        auto dstY1 = stack->pop<int32_t>();
        auto dstX1 = stack->pop<int32_t>();
        auto dstY0 = stack->pop<int32_t>();
        auto dstX0 = stack->pop<int32_t>();
        auto srcY1 = stack->pop<int32_t>();
        auto srcX1 = stack->pop<int32_t>();
        auto srcY0 = stack->pop<int32_t>();
        auto srcX0 = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlitFramebufferNV(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
            if (glBlitFramebufferNV != nullptr) {
                glBlitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlitFramebufferNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlitFramebufferNV");
            return false;
        }
    }

    bool Gles::callGlBufferStorageEXT(Stack* stack, bool pushReturn) {
        auto flag = stack->pop<GLbitfield>();
        auto data = stack->pop<void*>();
        auto size = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBufferStorageEXT(%u, %" PRId32 ", %p, %u)", target, size, data, flag);
            if (glBufferStorageEXT != nullptr) {
                glBufferStorageEXT(target, size, data, flag);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBufferStorageEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBufferStorageEXT");
            return false;
        }
    }

    bool Gles::callGlClientWaitSyncAPPLE(Stack* stack, bool pushReturn) {
        auto timeout = stack->pop<uint64_t>();
        auto flag = stack->pop<GLbitfield>();
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glClientWaitSyncAPPLE(%p, %u, %" PRIu64 ")", sync, flag, timeout);
            if (glClientWaitSyncAPPLE != nullptr) {
                GLenum return_value = glClientWaitSyncAPPLE(sync, flag, timeout);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClientWaitSyncAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClientWaitSyncAPPLE");
            return false;
        }
    }

    bool Gles::callGlColorMaskiOES(Stack* stack, bool pushReturn) {
        auto a = stack->pop<uint8_t>();
        auto b = stack->pop<uint8_t>();
        auto g = stack->pop<uint8_t>();
        auto r = stack->pop<uint8_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColorMaskiOES(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", index, r, g, b, a);
            if (glColorMaskiOES != nullptr) {
                glColorMaskiOES(index, r, g, b, a);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColorMaskiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColorMaskiOES");
            return false;
        }
    }

    bool Gles::callGlCompressedTexImage3DOES(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto image_size = stack->pop<int32_t>();
        auto border = stack->pop<int32_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCompressedTexImage3DOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)", target, level, internalformat, width, height, depth, border, image_size, data);
            if (glCompressedTexImage3DOES != nullptr) {
                glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, image_size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompressedTexImage3DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompressedTexImage3DOES");
            return false;
        }
    }

    bool Gles::callGlCompressedTexSubImage3DOES(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto image_size = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("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 (glCompressedTexSubImage3DOES != nullptr) {
                glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompressedTexSubImage3DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompressedTexSubImage3DOES");
            return false;
        }
    }

    bool Gles::callGlCopyBufferSubDataNV(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        auto writeOffset = stack->pop<int32_t>();
        auto readOffset = stack->pop<int32_t>();
        auto writeTarget = stack->pop<GLenum>();
        auto readTarget = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyBufferSubDataNV(%u, %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", readTarget, writeTarget, readOffset, writeOffset, size);
            if (glCopyBufferSubDataNV != nullptr) {
                glCopyBufferSubDataNV(readTarget, writeTarget, readOffset, writeOffset, size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyBufferSubDataNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyBufferSubDataNV");
            return false;
        }
    }

    bool Gles::callGlCopyImageSubDataOES(Stack* stack, bool pushReturn) {
        auto srcDepth = stack->pop<int32_t>();
        auto srcHeight = stack->pop<int32_t>();
        auto srcWidth = stack->pop<int32_t>();
        auto dstZ = stack->pop<int32_t>();
        auto dstY = stack->pop<int32_t>();
        auto dstX = stack->pop<int32_t>();
        auto dstLevel = stack->pop<int32_t>();
        auto dstTarget = stack->pop<GLenum>();
        auto dstName = stack->pop<uint32_t>();
        auto srcZ = stack->pop<int32_t>();
        auto srcY = stack->pop<int32_t>();
        auto srcX = stack->pop<int32_t>();
        auto srcLevel = stack->pop<int32_t>();
        auto srcTarget = stack->pop<GLenum>();
        auto srcName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("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 (glCopyImageSubDataOES != nullptr) {
                glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyImageSubDataOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyImageSubDataOES");
            return false;
        }
    }

    bool Gles::callGlCopyPathNV(Stack* stack, bool pushReturn) {
        auto srcPath = stack->pop<uint32_t>();
        auto resultPath = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyPathNV(%" PRIu32 ", %" PRIu32 ")", resultPath, srcPath);
            if (glCopyPathNV != nullptr) {
                glCopyPathNV(resultPath, srcPath);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyPathNV");
            return false;
        }
    }

    bool Gles::callGlCopyTexSubImage3DOES(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyTexSubImage3DOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, xoffset, yoffset, zoffset, x, y, width, height);
            if (glCopyTexSubImage3DOES != nullptr) {
                glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyTexSubImage3DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyTexSubImage3DOES");
            return false;
        }
    }

    bool Gles::callGlCopyTextureLevelsAPPLE(Stack* stack, bool pushReturn) {
        auto sourceLevelCount = stack->pop<int32_t>();
        auto sourceBaseLevel = stack->pop<int32_t>();
        auto sourceTexture = stack->pop<uint32_t>();
        auto destinationTexture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyTextureLevelsAPPLE(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")", destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
            if (glCopyTextureLevelsAPPLE != nullptr) {
                glCopyTextureLevelsAPPLE(destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyTextureLevelsAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyTextureLevelsAPPLE");
            return false;
        }
    }

    bool Gles::callGlCoverFillPathInstancedNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto coverMode = stack->pop<GLenum>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
            if (glCoverFillPathInstancedNV != nullptr) {
                glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverFillPathInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverFillPathInstancedNV");
            return false;
        }
    }

    bool Gles::callGlCoverFillPathNV(Stack* stack, bool pushReturn) {
        auto coverMode = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverFillPathNV(%" PRIu32 ", %u)", path, coverMode);
            if (glCoverFillPathNV != nullptr) {
                glCoverFillPathNV(path, coverMode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverFillPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverFillPathNV");
            return false;
        }
    }

    bool Gles::callGlCoverStrokePathInstancedNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto coverMode = stack->pop<GLenum>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
            if (glCoverStrokePathInstancedNV != nullptr) {
                glCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverStrokePathInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverStrokePathInstancedNV");
            return false;
        }
    }

    bool Gles::callGlCoverStrokePathNV(Stack* stack, bool pushReturn) {
        auto coverMode = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverStrokePathNV(%" PRIu32 ", %u)", path, coverMode);
            if (glCoverStrokePathNV != nullptr) {
                glCoverStrokePathNV(path, coverMode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverStrokePathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverStrokePathNV");
            return false;
        }
    }

    bool Gles::callGlCoverageMaskNV(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint8_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverageMaskNV(%" PRIu8 ")", mask);
            if (glCoverageMaskNV != nullptr) {
                glCoverageMaskNV(mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverageMaskNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverageMaskNV");
            return false;
        }
    }

    bool Gles::callGlCoverageModulationNV(Stack* stack, bool pushReturn) {
        auto components = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverageModulationNV(%u)", components);
            if (glCoverageModulationNV != nullptr) {
                glCoverageModulationNV(components);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverageModulationNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverageModulationNV");
            return false;
        }
    }

    bool Gles::callGlCoverageModulationTableNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverageModulationTableNV(%" PRId32 ", %p)", n, v);
            if (glCoverageModulationTableNV != nullptr) {
                glCoverageModulationTableNV(n, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverageModulationTableNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverageModulationTableNV");
            return false;
        }
    }

    bool Gles::callGlCoverageOperationNV(Stack* stack, bool pushReturn) {
        auto operation = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCoverageOperationNV(%u)", operation);
            if (glCoverageOperationNV != nullptr) {
                glCoverageOperationNV(operation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCoverageOperationNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCoverageOperationNV");
            return false;
        }
    }

    bool Gles::callGlCreatePerfQueryINTEL(Stack* stack, bool pushReturn) {
        auto queryHandle = stack->pop<GLuint*>();
        auto queryId = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCreatePerfQueryINTEL(%" PRIu32 ", %p)", queryId, queryHandle);
            if (glCreatePerfQueryINTEL != nullptr) {
                glCreatePerfQueryINTEL(queryId, queryHandle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCreatePerfQueryINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCreatePerfQueryINTEL");
            return false;
        }
    }

    bool Gles::callGlCreateShaderProgramvEXT(Stack* stack, bool pushReturn) {
        auto strings = stack->pop<GLchar**>();
        auto count = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCreateShaderProgramvEXT(%u, %" PRId32 ", %p)", type, count, strings);
            if (glCreateShaderProgramvEXT != nullptr) {
                GLuint return_value = glCreateShaderProgramvEXT(type, count, strings);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCreateShaderProgramvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCreateShaderProgramvEXT");
            return false;
        }
    }

    bool Gles::callGlDeleteFencesNV(Stack* stack, bool pushReturn) {
        auto fences = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteFencesNV(%" PRId32 ", %p)", n, fences);
            if (glDeleteFencesNV != nullptr) {
                glDeleteFencesNV(n, fences);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteFencesNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteFencesNV");
            return false;
        }
    }

    bool Gles::callGlDeletePathsNV(Stack* stack, bool pushReturn) {
        auto range = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeletePathsNV(%" PRIu32 ", %" PRId32 ")", path, range);
            if (glDeletePathsNV != nullptr) {
                glDeletePathsNV(path, range);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeletePathsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeletePathsNV");
            return false;
        }
    }

    bool Gles::callGlDeletePerfMonitorsAMD(Stack* stack, bool pushReturn) {
        auto monitors = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeletePerfMonitorsAMD(%" PRId32 ", %p)", n, monitors);
            if (glDeletePerfMonitorsAMD != nullptr) {
                glDeletePerfMonitorsAMD(n, monitors);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeletePerfMonitorsAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeletePerfMonitorsAMD");
            return false;
        }
    }

    bool Gles::callGlDeletePerfQueryINTEL(Stack* stack, bool pushReturn) {
        auto queryHandle = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeletePerfQueryINTEL(%" PRIu32 ")", queryHandle);
            if (glDeletePerfQueryINTEL != nullptr) {
                glDeletePerfQueryINTEL(queryHandle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeletePerfQueryINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeletePerfQueryINTEL");
            return false;
        }
    }

    bool Gles::callGlDeleteProgramPipelinesEXT(Stack* stack, bool pushReturn) {
        auto pipelines = stack->pop<PipelineId*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteProgramPipelinesEXT(%" PRId32 ", %p)", n, pipelines);
            if (glDeleteProgramPipelinesEXT != nullptr) {
                glDeleteProgramPipelinesEXT(n, pipelines);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteProgramPipelinesEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteProgramPipelinesEXT");
            return false;
        }
    }

    bool Gles::callGlDeleteQueriesEXT(Stack* stack, bool pushReturn) {
        auto queries = stack->pop<QueryId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteQueriesEXT(%" PRId32 ", %p)", count, queries);
            if (glDeleteQueriesEXT != nullptr) {
                glDeleteQueriesEXT(count, queries);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteQueriesEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteQueriesEXT");
            return false;
        }
    }

    bool Gles::callGlDeleteSyncAPPLE(Stack* stack, bool pushReturn) {
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteSyncAPPLE(%p)", sync);
            if (glDeleteSyncAPPLE != nullptr) {
                glDeleteSyncAPPLE(sync);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteSyncAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteSyncAPPLE");
            return false;
        }
    }

    bool Gles::callGlDeleteVertexArraysOES(Stack* stack, bool pushReturn) {
        auto arrays = stack->pop<VertexArrayId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteVertexArraysOES(%" PRId32 ", %p)", count, arrays);
            if (glDeleteVertexArraysOES != nullptr) {
                glDeleteVertexArraysOES(count, arrays);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteVertexArraysOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteVertexArraysOES");
            return false;
        }
    }

    bool Gles::callGlDepthRangeArrayfvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto first = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthRangeArrayfvNV(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
            if (glDepthRangeArrayfvNV != nullptr) {
                glDepthRangeArrayfvNV(first, count, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthRangeArrayfvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthRangeArrayfvNV");
            return false;
        }
    }

    bool Gles::callGlDepthRangeIndexedfNV(Stack* stack, bool pushReturn) {
        auto f = stack->pop<float>();
        auto n = stack->pop<float>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthRangeIndexedfNV(%" PRIu32 ", %f, %f)", index, n, f);
            if (glDepthRangeIndexedfNV != nullptr) {
                glDepthRangeIndexedfNV(index, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthRangeIndexedfNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthRangeIndexedfNV");
            return false;
        }
    }

    bool Gles::callGlDisableDriverControlQCOM(Stack* stack, bool pushReturn) {
        auto driverControl = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDisableDriverControlQCOM(%" PRIu32 ")", driverControl);
            if (glDisableDriverControlQCOM != nullptr) {
                glDisableDriverControlQCOM(driverControl);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisableDriverControlQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisableDriverControlQCOM");
            return false;
        }
    }

    bool Gles::callGlDisableiNV(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDisableiNV(%u, %" PRIu32 ")", target, index);
            if (glDisableiNV != nullptr) {
                glDisableiNV(target, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisableiNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisableiNV");
            return false;
        }
    }

    bool Gles::callGlDisableiOES(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDisableiOES(%u, %" PRIu32 ")", target, index);
            if (glDisableiOES != nullptr) {
                glDisableiOES(target, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisableiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisableiOES");
            return false;
        }
    }

    bool Gles::callGlDiscardFramebufferEXT(Stack* stack, bool pushReturn) {
        auto attachments = stack->pop<GLenum*>();
        auto numAttachments = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDiscardFramebufferEXT(%u, %" PRId32 ", %p)", target, numAttachments, attachments);
            if (glDiscardFramebufferEXT != nullptr) {
                glDiscardFramebufferEXT(target, numAttachments, attachments);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDiscardFramebufferEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDiscardFramebufferEXT");
            return false;
        }
    }

    bool Gles::callGlDrawArraysInstancedANGLE(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto count = stack->pop<int32_t>();
        auto first = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArraysInstancedANGLE(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", mode, first, count, primcount);
            if (glDrawArraysInstancedANGLE != nullptr) {
                glDrawArraysInstancedANGLE(mode, first, count, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedANGLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArraysInstancedANGLE");
            return false;
        }
    }

    bool Gles::callGlDrawArraysInstancedBaseInstanceEXT(Stack* stack, bool pushReturn) {
        auto baseinstance = stack->pop<uint32_t>();
        auto instancecount = stack->pop<int32_t>();
        auto count = stack->pop<int32_t>();
        auto first = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArraysInstancedBaseInstanceEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu32 ")", mode, first, count, instancecount, baseinstance);
            if (glDrawArraysInstancedBaseInstanceEXT != nullptr) {
                glDrawArraysInstancedBaseInstanceEXT(mode, first, count, instancecount, baseinstance);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedBaseInstanceEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArraysInstancedBaseInstanceEXT");
            return false;
        }
    }

    bool Gles::callGlDrawArraysInstancedEXT(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto count = stack->pop<int32_t>();
        auto start = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArraysInstancedEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", mode, start, count, primcount);
            if (glDrawArraysInstancedEXT != nullptr) {
                glDrawArraysInstancedEXT(mode, start, count, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArraysInstancedEXT");
            return false;
        }
    }

    bool Gles::callGlDrawArraysInstancedNV(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto count = stack->pop<int32_t>();
        auto first = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawArraysInstancedNV(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", mode, first, count, primcount);
            if (glDrawArraysInstancedNV != nullptr) {
                glDrawArraysInstancedNV(mode, first, count, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawArraysInstancedNV");
            return false;
        }
    }

    bool Gles::callGlDrawBuffersEXT(Stack* stack, bool pushReturn) {
        auto bufs = stack->pop<GLenum*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawBuffersEXT(%" PRId32 ", %p)", n, bufs);
            if (glDrawBuffersEXT != nullptr) {
                glDrawBuffersEXT(n, bufs);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawBuffersEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawBuffersEXT");
            return false;
        }
    }

    bool Gles::callGlDrawBuffersIndexedEXT(Stack* stack, bool pushReturn) {
        auto indices = stack->pop<GLint*>();
        auto location = stack->pop<GLenum*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawBuffersIndexedEXT(%" PRId32 ", %p, %p)", n, location, indices);
            if (glDrawBuffersIndexedEXT != nullptr) {
                glDrawBuffersIndexedEXT(n, location, indices);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawBuffersIndexedEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawBuffersIndexedEXT");
            return false;
        }
    }

    bool Gles::callGlDrawBuffersNV(Stack* stack, bool pushReturn) {
        auto bufs = stack->pop<GLenum*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawBuffersNV(%" PRId32 ", %p)", n, bufs);
            if (glDrawBuffersNV != nullptr) {
                glDrawBuffersNV(n, bufs);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawBuffersNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawBuffersNV");
            return false;
        }
    }

    bool Gles::callGlDrawElementsBaseVertexEXT(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsBaseVertexEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, basevertex);
            if (glDrawElementsBaseVertexEXT != nullptr) {
                glDrawElementsBaseVertexEXT(mode, count, type, indices, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsBaseVertexEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsBaseVertexEXT");
            return false;
        }
    }

    bool Gles::callGlDrawElementsBaseVertexOES(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsBaseVertexOES(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, basevertex);
            if (glDrawElementsBaseVertexOES != nullptr) {
                glDrawElementsBaseVertexOES(mode, count, type, indices, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsBaseVertexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsBaseVertexOES");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedANGLE(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedANGLE(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
            if (glDrawElementsInstancedANGLE != nullptr) {
                glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedANGLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedANGLE");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedBaseInstanceEXT(Stack* stack, bool pushReturn) {
        auto baseinstance = stack->pop<uint32_t>();
        auto instancecount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedBaseInstanceEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRIu32 ")", mode, count, type, indices, instancecount, baseinstance);
            if (glDrawElementsInstancedBaseInstanceEXT != nullptr) {
                glDrawElementsInstancedBaseInstanceEXT(mode, count, type, indices, instancecount, baseinstance);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedBaseInstanceEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedBaseInstanceEXT");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedBaseVertexBaseInstanceEXT(Stack* stack, bool pushReturn) {
        auto baseinstance = stack->pop<uint32_t>();
        auto basevertex = stack->pop<int32_t>();
        auto instancecount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedBaseVertexBaseInstanceEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ", %" PRIu32 ")", mode, count, type, indices, instancecount, basevertex, baseinstance);
            if (glDrawElementsInstancedBaseVertexBaseInstanceEXT != nullptr) {
                glDrawElementsInstancedBaseVertexBaseInstanceEXT(mode, count, type, indices, instancecount, basevertex, baseinstance);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedBaseVertexBaseInstanceEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedBaseVertexBaseInstanceEXT");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedBaseVertexEXT(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<int32_t>();
        auto instancecount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedBaseVertexEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ")", mode, count, type, indices, instancecount, basevertex);
            if (glDrawElementsInstancedBaseVertexEXT != nullptr) {
                glDrawElementsInstancedBaseVertexEXT(mode, count, type, indices, instancecount, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedBaseVertexEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedBaseVertexEXT");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedBaseVertexOES(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<int32_t>();
        auto instancecount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedBaseVertexOES(%u, %" PRId32 ", %u, %p, %" PRId32 ", %" PRId32 ")", mode, count, type, indices, instancecount, basevertex);
            if (glDrawElementsInstancedBaseVertexOES != nullptr) {
                glDrawElementsInstancedBaseVertexOES(mode, count, type, indices, instancecount, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedBaseVertexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedBaseVertexOES");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedEXT(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedEXT(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
            if (glDrawElementsInstancedEXT != nullptr) {
                glDrawElementsInstancedEXT(mode, count, type, indices, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedEXT");
            return false;
        }
    }

    bool Gles::callGlDrawElementsInstancedNV(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawElementsInstancedNV(%u, %" PRId32 ", %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
            if (glDrawElementsInstancedNV != nullptr) {
                glDrawElementsInstancedNV(mode, count, type, indices, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawElementsInstancedNV");
            return false;
        }
    }

    bool Gles::callGlDrawRangeElementsBaseVertexEXT(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto end = stack->pop<uint32_t>();
        auto start = stack->pop<uint32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawRangeElementsBaseVertexEXT(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p, %" PRId32 ")", mode, start, end, count, type, indices, basevertex);
            if (glDrawRangeElementsBaseVertexEXT != nullptr) {
                glDrawRangeElementsBaseVertexEXT(mode, start, end, count, type, indices, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawRangeElementsBaseVertexEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawRangeElementsBaseVertexEXT");
            return false;
        }
    }

    bool Gles::callGlDrawRangeElementsBaseVertexOES(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<int32_t>();
        auto indices = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<int32_t>();
        auto end = stack->pop<uint32_t>();
        auto start = stack->pop<uint32_t>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawRangeElementsBaseVertexOES(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p, %" PRId32 ")", mode, start, end, count, type, indices, basevertex);
            if (glDrawRangeElementsBaseVertexOES != nullptr) {
                glDrawRangeElementsBaseVertexOES(mode, start, end, count, type, indices, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawRangeElementsBaseVertexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawRangeElementsBaseVertexOES");
            return false;
        }
    }

    bool Gles::callGlEGLImageTargetRenderbufferStorageOES(Stack* stack, bool pushReturn) {
        auto image = stack->pop<void*>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEGLImageTargetRenderbufferStorageOES(%u, %p)", target, image);
            if (glEGLImageTargetRenderbufferStorageOES != nullptr) {
                glEGLImageTargetRenderbufferStorageOES(target, image);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEGLImageTargetRenderbufferStorageOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEGLImageTargetRenderbufferStorageOES");
            return false;
        }
    }

    bool Gles::callGlEGLImageTargetTexture2DOES(Stack* stack, bool pushReturn) {
        auto image = stack->pop<void*>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEGLImageTargetTexture2DOES(%u, %p)", target, image);
            if (glEGLImageTargetTexture2DOES != nullptr) {
                glEGLImageTargetTexture2DOES(target, image);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEGLImageTargetTexture2DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEGLImageTargetTexture2DOES");
            return false;
        }
    }

    bool Gles::callGlEnableDriverControlQCOM(Stack* stack, bool pushReturn) {
        auto driverControl = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glEnableDriverControlQCOM(%" PRIu32 ")", driverControl);
            if (glEnableDriverControlQCOM != nullptr) {
                glEnableDriverControlQCOM(driverControl);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnableDriverControlQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnableDriverControlQCOM");
            return false;
        }
    }

    bool Gles::callGlEnableiNV(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEnableiNV(%u, %" PRIu32 ")", target, index);
            if (glEnableiNV != nullptr) {
                glEnableiNV(target, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnableiNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnableiNV");
            return false;
        }
    }

    bool Gles::callGlEnableiOES(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEnableiOES(%u, %" PRIu32 ")", target, index);
            if (glEnableiOES != nullptr) {
                glEnableiOES(target, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnableiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnableiOES");
            return false;
        }
    }

    bool Gles::callGlEndConditionalRenderNV(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glEndConditionalRenderNV()");
            if (glEndConditionalRenderNV != nullptr) {
                glEndConditionalRenderNV();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndConditionalRenderNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndConditionalRenderNV");
            return false;
        }
    }

    bool Gles::callGlEndPerfMonitorAMD(Stack* stack, bool pushReturn) {
        auto monitor = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glEndPerfMonitorAMD(%" PRIu32 ")", monitor);
            if (glEndPerfMonitorAMD != nullptr) {
                glEndPerfMonitorAMD(monitor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndPerfMonitorAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndPerfMonitorAMD");
            return false;
        }
    }

    bool Gles::callGlEndPerfQueryINTEL(Stack* stack, bool pushReturn) {
        auto queryHandle = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glEndPerfQueryINTEL(%" PRIu32 ")", queryHandle);
            if (glEndPerfQueryINTEL != nullptr) {
                glEndPerfQueryINTEL(queryHandle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndPerfQueryINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndPerfQueryINTEL");
            return false;
        }
    }

    bool Gles::callGlEndQueryEXT(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEndQueryEXT(%u)", target);
            if (glEndQueryEXT != nullptr) {
                glEndQueryEXT(target);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndQueryEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndQueryEXT");
            return false;
        }
    }

    bool Gles::callGlEndTilingQCOM(Stack* stack, bool pushReturn) {
        auto preserve_mask = stack->pop<GLbitfield>();
        if (stack->isValid()) {
            GAPID_INFO("glEndTilingQCOM(%u)", preserve_mask);
            if (glEndTilingQCOM != nullptr) {
                glEndTilingQCOM(preserve_mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndTilingQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndTilingQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetBufferPointervQCOM(Stack* stack, bool pushReturn) {
        auto params = stack->pop<void**>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetBufferPointervQCOM(%u, %p)", target, params);
            if (glExtGetBufferPointervQCOM != nullptr) {
                glExtGetBufferPointervQCOM(target, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetBufferPointervQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetBufferPointervQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetBuffersQCOM(Stack* stack, bool pushReturn) {
        auto numBuffers = stack->pop<GLint*>();
        auto maxBuffers = stack->pop<int32_t>();
        auto buffers = stack->pop<BufferId*>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetBuffersQCOM(%p, %" PRId32 ", %p)", buffers, maxBuffers, numBuffers);
            if (glExtGetBuffersQCOM != nullptr) {
                glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetBuffersQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetBuffersQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetFramebuffersQCOM(Stack* stack, bool pushReturn) {
        auto numFramebuffers = stack->pop<GLint*>();
        auto maxFramebuffers = stack->pop<int32_t>();
        auto framebuffers = stack->pop<FramebufferId*>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetFramebuffersQCOM(%p, %" PRId32 ", %p)", framebuffers, maxFramebuffers, numFramebuffers);
            if (glExtGetFramebuffersQCOM != nullptr) {
                glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetFramebuffersQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetFramebuffersQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetProgramBinarySourceQCOM(Stack* stack, bool pushReturn) {
        auto length = stack->pop<GLint*>();
        auto source = stack->pop<GLchar*>();
        auto shadertype = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetProgramBinarySourceQCOM(%" PRIu32 ", %u, %p, %p)", program, shadertype, source, length);
            if (glExtGetProgramBinarySourceQCOM != nullptr) {
                glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetProgramBinarySourceQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetProgramBinarySourceQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetProgramsQCOM(Stack* stack, bool pushReturn) {
        auto numPrograms = stack->pop<GLint*>();
        auto maxPrograms = stack->pop<int32_t>();
        auto programs = stack->pop<ProgramId*>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetProgramsQCOM(%p, %" PRId32 ", %p)", programs, maxPrograms, numPrograms);
            if (glExtGetProgramsQCOM != nullptr) {
                glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetProgramsQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetProgramsQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetRenderbuffersQCOM(Stack* stack, bool pushReturn) {
        auto numRenderbuffers = stack->pop<GLint*>();
        auto maxRenderbuffers = stack->pop<int32_t>();
        auto renderbuffers = stack->pop<RenderbufferId*>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetRenderbuffersQCOM(%p, %" PRId32 ", %p)", renderbuffers, maxRenderbuffers, numRenderbuffers);
            if (glExtGetRenderbuffersQCOM != nullptr) {
                glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetRenderbuffersQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetRenderbuffersQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetShadersQCOM(Stack* stack, bool pushReturn) {
        auto numShaders = stack->pop<GLint*>();
        auto maxShaders = stack->pop<int32_t>();
        auto shaders = stack->pop<ShaderId*>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetShadersQCOM(%p, %" PRId32 ", %p)", shaders, maxShaders, numShaders);
            if (glExtGetShadersQCOM != nullptr) {
                glExtGetShadersQCOM(shaders, maxShaders, numShaders);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetShadersQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetShadersQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetTexLevelParameterivQCOM(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto face = stack->pop<GLenum>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetTexLevelParameterivQCOM(%" PRIu32 ", %u, %" PRId32 ", %u, %p)", texture, face, level, pname, params);
            if (glExtGetTexLevelParameterivQCOM != nullptr) {
                glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetTexLevelParameterivQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetTexLevelParameterivQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetTexSubImageQCOM(Stack* stack, bool pushReturn) {
        auto texels = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetTexSubImageQCOM(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
            if (glExtGetTexSubImageQCOM != nullptr) {
                glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetTexSubImageQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetTexSubImageQCOM");
            return false;
        }
    }

    bool Gles::callGlExtGetTexturesQCOM(Stack* stack, bool pushReturn) {
        auto numTextures = stack->pop<GLint*>();
        auto maxTextures = stack->pop<int32_t>();
        auto textures = stack->pop<TextureId*>();
        if (stack->isValid()) {
            GAPID_INFO("glExtGetTexturesQCOM(%p, %" PRId32 ", %p)", textures, maxTextures, numTextures);
            if (glExtGetTexturesQCOM != nullptr) {
                glExtGetTexturesQCOM(textures, maxTextures, numTextures);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtGetTexturesQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtGetTexturesQCOM");
            return false;
        }
    }

    bool Gles::callGlExtIsProgramBinaryQCOM(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glExtIsProgramBinaryQCOM(%" PRIu32 ")", program);
            if (glExtIsProgramBinaryQCOM != nullptr) {
                GLboolean return_value = glExtIsProgramBinaryQCOM(program);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtIsProgramBinaryQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtIsProgramBinaryQCOM");
            return false;
        }
    }

    bool Gles::callGlExtTexObjectStateOverrideiQCOM(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glExtTexObjectStateOverrideiQCOM(%u, %u, %" PRId32 ")", target, pname, param);
            if (glExtTexObjectStateOverrideiQCOM != nullptr) {
                glExtTexObjectStateOverrideiQCOM(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glExtTexObjectStateOverrideiQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glExtTexObjectStateOverrideiQCOM");
            return false;
        }
    }

    bool Gles::callGlFenceSyncAPPLE(Stack* stack, bool pushReturn) {
        auto flag = stack->pop<GLbitfield>();
        auto condition = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFenceSyncAPPLE(%u, %u)", condition, flag);
            if (glFenceSyncAPPLE != nullptr) {
                GLsync return_value = glFenceSyncAPPLE(condition, flag);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<GLsync>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFenceSyncAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFenceSyncAPPLE");
            return false;
        }
    }

    bool Gles::callGlFinishFenceNV(Stack* stack, bool pushReturn) {
        auto fence = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glFinishFenceNV(%" PRIu32 ")", fence);
            if (glFinishFenceNV != nullptr) {
                glFinishFenceNV(fence);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFinishFenceNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFinishFenceNV");
            return false;
        }
    }

    bool Gles::callGlFlushMappedBufferRangeEXT(Stack* stack, bool pushReturn) {
        auto length = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFlushMappedBufferRangeEXT(%u, %" PRId32 ", %" PRId32 ")", target, offset, length);
            if (glFlushMappedBufferRangeEXT != nullptr) {
                glFlushMappedBufferRangeEXT(target, offset, length);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFlushMappedBufferRangeEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFlushMappedBufferRangeEXT");
            return false;
        }
    }

    bool Gles::callGlFragmentCoverageColorNV(Stack* stack, bool pushReturn) {
        auto color = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glFragmentCoverageColorNV(%" PRIu32 ")", color);
            if (glFragmentCoverageColorNV != nullptr) {
                glFragmentCoverageColorNV(color);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFragmentCoverageColorNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFragmentCoverageColorNV");
            return false;
        }
    }

    bool Gles::callGlFramebufferSampleLocationsfvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto start = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferSampleLocationsfvNV(%u, %" PRIu32 ", %" PRId32 ", %p)", target, start, count, v);
            if (glFramebufferSampleLocationsfvNV != nullptr) {
                glFramebufferSampleLocationsfvNV(target, start, count, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferSampleLocationsfvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferSampleLocationsfvNV");
            return false;
        }
    }

    bool Gles::callGlFramebufferTexture2DMultisampleEXT(Stack* stack, bool pushReturn) {
        auto samples = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto textarget = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTexture2DMultisampleEXT(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, samples);
            if (glFramebufferTexture2DMultisampleEXT != nullptr) {
                glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture2DMultisampleEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTexture2DMultisampleEXT");
            return false;
        }
    }

    bool Gles::callGlFramebufferTexture2DMultisampleIMG(Stack* stack, bool pushReturn) {
        auto samples = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto textarget = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTexture2DMultisampleIMG(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, samples);
            if (glFramebufferTexture2DMultisampleIMG != nullptr) {
                glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture2DMultisampleIMG");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTexture2DMultisampleIMG");
            return false;
        }
    }

    bool Gles::callGlFramebufferTexture3DOES(Stack* stack, bool pushReturn) {
        auto zoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto textarget = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTexture3DOES(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, zoffset);
            if (glFramebufferTexture3DOES != nullptr) {
                glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture3DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTexture3DOES");
            return false;
        }
    }

    bool Gles::callGlFramebufferTextureMultiviewOVR(Stack* stack, bool pushReturn) {
        auto numViews = stack->pop<int32_t>();
        auto baseViewIndex = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTextureMultiviewOVR(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, baseViewIndex, numViews);
            if (glFramebufferTextureMultiviewOVR != nullptr) {
                glFramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTextureMultiviewOVR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTextureMultiviewOVR");
            return false;
        }
    }

    bool Gles::callGlFramebufferTextureOES(Stack* stack, bool pushReturn) {
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTextureOES(%u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, texture, level);
            if (glFramebufferTextureOES != nullptr) {
                glFramebufferTextureOES(target, attachment, texture, level);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTextureOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTextureOES");
            return false;
        }
    }

    bool Gles::callGlGenFencesNV(Stack* stack, bool pushReturn) {
        auto fences = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenFencesNV(%" PRId32 ", %p)", n, fences);
            if (glGenFencesNV != nullptr) {
                glGenFencesNV(n, fences);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenFencesNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenFencesNV");
            return false;
        }
    }

    bool Gles::callGlGenPathsNV(Stack* stack, bool pushReturn) {
        auto range = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenPathsNV(%" PRId32 ")", range);
            if (glGenPathsNV != nullptr) {
                GLuint return_value = glGenPathsNV(range);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenPathsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenPathsNV");
            return false;
        }
    }

    bool Gles::callGlGenPerfMonitorsAMD(Stack* stack, bool pushReturn) {
        auto monitors = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenPerfMonitorsAMD(%" PRId32 ", %p)", n, monitors);
            if (glGenPerfMonitorsAMD != nullptr) {
                glGenPerfMonitorsAMD(n, monitors);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenPerfMonitorsAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenPerfMonitorsAMD");
            return false;
        }
    }

    bool Gles::callGlGenProgramPipelinesEXT(Stack* stack, bool pushReturn) {
        auto pipelines = stack->pop<PipelineId*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenProgramPipelinesEXT(%" PRId32 ", %p)", n, pipelines);
            if (glGenProgramPipelinesEXT != nullptr) {
                glGenProgramPipelinesEXT(n, pipelines);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenProgramPipelinesEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenProgramPipelinesEXT");
            return false;
        }
    }

    bool Gles::callGlGenQueriesEXT(Stack* stack, bool pushReturn) {
        auto queries = stack->pop<QueryId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenQueriesEXT(%" PRId32 ", %p)", count, queries);
            if (glGenQueriesEXT != nullptr) {
                glGenQueriesEXT(count, queries);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenQueriesEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenQueriesEXT");
            return false;
        }
    }

    bool Gles::callGlGenVertexArraysOES(Stack* stack, bool pushReturn) {
        auto arrays = stack->pop<VertexArrayId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenVertexArraysOES(%" PRId32 ", %p)", count, arrays);
            if (glGenVertexArraysOES != nullptr) {
                glGenVertexArraysOES(count, arrays);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenVertexArraysOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenVertexArraysOES");
            return false;
        }
    }

    bool Gles::callGlGetBufferPointervOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<void**>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetBufferPointervOES(%u, %u, %p)", target, pname, params);
            if (glGetBufferPointervOES != nullptr) {
                glGetBufferPointervOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetBufferPointervOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetBufferPointervOES");
            return false;
        }
    }

    bool Gles::callGlGetCoverageModulationTableNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto bufsize = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetCoverageModulationTableNV(%" PRId32 ", %p)", bufsize, v);
            if (glGetCoverageModulationTableNV != nullptr) {
                glGetCoverageModulationTableNV(bufsize, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetCoverageModulationTableNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetCoverageModulationTableNV");
            return false;
        }
    }

    bool Gles::callGlGetDriverControlStringQCOM(Stack* stack, bool pushReturn) {
        auto driverControlString = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto driverControl = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetDriverControlStringQCOM(%" PRIu32 ", %" PRId32 ", %p, %p)", driverControl, bufSize, length, driverControlString);
            if (glGetDriverControlStringQCOM != nullptr) {
                glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetDriverControlStringQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetDriverControlStringQCOM");
            return false;
        }
    }

    bool Gles::callGlGetDriverControlsQCOM(Stack* stack, bool pushReturn) {
        auto driverControls = stack->pop<GLuint*>();
        auto size = stack->pop<int32_t>();
        auto num = stack->pop<GLint*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetDriverControlsQCOM(%p, %" PRId32 ", %p)", num, size, driverControls);
            if (glGetDriverControlsQCOM != nullptr) {
                glGetDriverControlsQCOM(num, size, driverControls);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetDriverControlsQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetDriverControlsQCOM");
            return false;
        }
    }

    bool Gles::callGlGetFenceivNV(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto fence = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFenceivNV(%" PRIu32 ", %u, %p)", fence, pname, params);
            if (glGetFenceivNV != nullptr) {
                glGetFenceivNV(fence, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFenceivNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFenceivNV");
            return false;
        }
    }

    bool Gles::callGlGetFirstPerfQueryIdINTEL(Stack* stack, bool pushReturn) {
        auto queryId = stack->pop<GLuint*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFirstPerfQueryIdINTEL(%p)", queryId);
            if (glGetFirstPerfQueryIdINTEL != nullptr) {
                glGetFirstPerfQueryIdINTEL(queryId);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFirstPerfQueryIdINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFirstPerfQueryIdINTEL");
            return false;
        }
    }

    bool Gles::callGlGetFloatiVNV(Stack* stack, bool pushReturn) {
        auto data = stack->pop<GLfloat*>();
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFloati_vNV(%u, %" PRIu32 ", %p)", target, index, data);
            if (glGetFloati_vNV != nullptr) {
                glGetFloati_vNV(target, index, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFloati_vNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFloati_vNV");
            return false;
        }
    }

    bool Gles::callGlGetFragDataIndexEXT(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFragDataIndexEXT(%" PRIu32 ", %s)", program, name);
            if (glGetFragDataIndexEXT != nullptr) {
                GLint return_value = glGetFragDataIndexEXT(program, name);
                GAPID_INFO("Returned: %" PRId32 "", return_value);
                if (pushReturn) {
                    stack->push<GLint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFragDataIndexEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFragDataIndexEXT");
            return false;
        }
    }

    bool Gles::callGlGetGraphicsResetStatusEXT(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glGetGraphicsResetStatusEXT()");
            if (glGetGraphicsResetStatusEXT != nullptr) {
                GLenum return_value = glGetGraphicsResetStatusEXT();
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetGraphicsResetStatusEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetGraphicsResetStatusEXT");
            return false;
        }
    }

    bool Gles::callGlGetGraphicsResetStatusKHR(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glGetGraphicsResetStatusKHR()");
            if (glGetGraphicsResetStatusKHR != nullptr) {
                GLenum return_value = glGetGraphicsResetStatusKHR();
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetGraphicsResetStatusKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetGraphicsResetStatusKHR");
            return false;
        }
    }

    bool Gles::callGlGetImageHandleNV(Stack* stack, bool pushReturn) {
        auto format = stack->pop<GLenum>();
        auto layer = stack->pop<int32_t>();
        auto layered = stack->pop<uint8_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetImageHandleNV(%" PRIu32 ", %" PRId32 ", %" PRIu8 ", %" PRId32 ", %u)", texture, level, layered, layer, format);
            if (glGetImageHandleNV != nullptr) {
                GLuint64 return_value = glGetImageHandleNV(texture, level, layered, layer, format);
                GAPID_INFO("Returned: %" PRIu64 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint64>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetImageHandleNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetImageHandleNV");
            return false;
        }
    }

    bool Gles::callGlGetInteger64vAPPLE(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint64*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetInteger64vAPPLE(%u, %p)", pname, params);
            if (glGetInteger64vAPPLE != nullptr) {
                glGetInteger64vAPPLE(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetInteger64vAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetInteger64vAPPLE");
            return false;
        }
    }

    bool Gles::callGlGetIntegeriVEXT(Stack* stack, bool pushReturn) {
        auto data = stack->pop<GLint*>();
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetIntegeri_vEXT(%u, %" PRIu32 ", %p)", target, index, data);
            if (glGetIntegeri_vEXT != nullptr) {
                glGetIntegeri_vEXT(target, index, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetIntegeri_vEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetIntegeri_vEXT");
            return false;
        }
    }

    bool Gles::callGlGetInternalformatSampleivNV(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto bufSize = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetInternalformatSampleivNV(%u, %u, %" PRId32 ", %u, %" PRId32 ", %p)", target, internalformat, samples, pname, bufSize, params);
            if (glGetInternalformatSampleivNV != nullptr) {
                glGetInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetInternalformatSampleivNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetInternalformatSampleivNV");
            return false;
        }
    }

    bool Gles::callGlGetNextPerfQueryIdINTEL(Stack* stack, bool pushReturn) {
        auto nextQueryId = stack->pop<GLuint*>();
        auto queryId = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetNextPerfQueryIdINTEL(%" PRIu32 ", %p)", queryId, nextQueryId);
            if (glGetNextPerfQueryIdINTEL != nullptr) {
                glGetNextPerfQueryIdINTEL(queryId, nextQueryId);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetNextPerfQueryIdINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetNextPerfQueryIdINTEL");
            return false;
        }
    }

    bool Gles::callGlGetObjectLabelEXT(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto object = stack->pop<uint32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetObjectLabelEXT(%u, %" PRIu32 ", %" PRId32 ", %p, %p)", type, object, bufSize, length, label);
            if (glGetObjectLabelEXT != nullptr) {
                glGetObjectLabelEXT(type, object, bufSize, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetObjectLabelEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetObjectLabelEXT");
            return false;
        }
    }

    bool Gles::callGlGetPathCommandsNV(Stack* stack, bool pushReturn) {
        auto commands = stack->pop<GLubyte*>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathCommandsNV(%" PRIu32 ", %p)", path, commands);
            if (glGetPathCommandsNV != nullptr) {
                glGetPathCommandsNV(path, commands);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathCommandsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathCommandsNV");
            return false;
        }
    }

    bool Gles::callGlGetPathCoordsNV(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<GLfloat*>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathCoordsNV(%" PRIu32 ", %p)", path, coords);
            if (glGetPathCoordsNV != nullptr) {
                glGetPathCoordsNV(path, coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathCoordsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathCoordsNV");
            return false;
        }
    }

    bool Gles::callGlGetPathDashArrayNV(Stack* stack, bool pushReturn) {
        auto dashArray = stack->pop<GLfloat*>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathDashArrayNV(%" PRIu32 ", %p)", path, dashArray);
            if (glGetPathDashArrayNV != nullptr) {
                glGetPathDashArrayNV(path, dashArray);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathDashArrayNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathDashArrayNV");
            return false;
        }
    }

    bool Gles::callGlGetPathLengthNV(Stack* stack, bool pushReturn) {
        auto numSegments = stack->pop<int32_t>();
        auto startSegment = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathLengthNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ")", path, startSegment, numSegments);
            if (glGetPathLengthNV != nullptr) {
                GLfloat return_value = glGetPathLengthNV(path, startSegment, numSegments);
                GAPID_INFO("Returned: %f", return_value);
                if (pushReturn) {
                    stack->push<GLfloat>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathLengthNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathLengthNV");
            return false;
        }
    }

    bool Gles::callGlGetPathMetricRangeNV(Stack* stack, bool pushReturn) {
        auto metrics = stack->pop<GLfloat*>();
        auto stride = stack->pop<int32_t>();
        auto numPaths = stack->pop<int32_t>();
        auto firstPathName = stack->pop<uint32_t>();
        auto metricQueryMask = stack->pop<GLbitfield>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathMetricRangeNV(%u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", metricQueryMask, firstPathName, numPaths, stride, metrics);
            if (glGetPathMetricRangeNV != nullptr) {
                glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathMetricRangeNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathMetricRangeNV");
            return false;
        }
    }

    bool Gles::callGlGetPathMetricsNV(Stack* stack, bool pushReturn) {
        auto metrics = stack->pop<GLfloat*>();
        auto stride = stack->pop<int32_t>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        auto metricQueryMask = stack->pop<GLbitfield>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathMetricsNV(%u, %" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %p)", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
            if (glGetPathMetricsNV != nullptr) {
                glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathMetricsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathMetricsNV");
            return false;
        }
    }

    bool Gles::callGlGetPathParameterfvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathParameterfvNV(%" PRIu32 ", %u, %p)", path, pname, value);
            if (glGetPathParameterfvNV != nullptr) {
                glGetPathParameterfvNV(path, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathParameterfvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathParameterfvNV");
            return false;
        }
    }

    bool Gles::callGlGetPathParameterivNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathParameterivNV(%" PRIu32 ", %u, %p)", path, pname, value);
            if (glGetPathParameterivNV != nullptr) {
                glGetPathParameterivNV(path, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathParameterivNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathParameterivNV");
            return false;
        }
    }

    bool Gles::callGlGetPathSpacingNV(Stack* stack, bool pushReturn) {
        auto returnedSpacing = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto kerningScale = stack->pop<float>();
        auto advanceScale = stack->pop<float>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        auto pathListMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPathSpacingNV(%u, %" PRId32 ", %u, %p, %" PRIu32 ", %f, %f, %u, %p)", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
            if (glGetPathSpacingNV != nullptr) {
                glGetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPathSpacingNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPathSpacingNV");
            return false;
        }
    }

    bool Gles::callGlGetPerfCounterInfoINTEL(Stack* stack, bool pushReturn) {
        auto rawCounterMaxValue = stack->pop<GLuint64*>();
        auto counterDataTypeEnum = stack->pop<GLuint*>();
        auto counterTypeEnum = stack->pop<GLuint*>();
        auto counterDataSize = stack->pop<GLuint*>();
        auto counterOffset = stack->pop<GLuint*>();
        auto counterDesc = stack->pop<GLchar*>();
        auto counterDescLength = stack->pop<uint32_t>();
        auto counterName = stack->pop<GLchar*>();
        auto counterNameLength = stack->pop<uint32_t>();
        auto counterId = stack->pop<uint32_t>();
        auto queryId = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfCounterInfoINTEL(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %p, %" PRIu32 ", %p, %p, %p, %p, %p, %p)", queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
            if (glGetPerfCounterInfoINTEL != nullptr) {
                glGetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfCounterInfoINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfCounterInfoINTEL");
            return false;
        }
    }

    bool Gles::callGlGetPerfMonitorCounterDataAMD(Stack* stack, bool pushReturn) {
        auto bytesWritten = stack->pop<GLint*>();
        auto data = stack->pop<GLuint*>();
        auto dataSize = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto monitor = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfMonitorCounterDataAMD(%" PRIu32 ", %u, %" PRId32 ", %p, %p)", monitor, pname, dataSize, data, bytesWritten);
            if (glGetPerfMonitorCounterDataAMD != nullptr) {
                glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorCounterDataAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfMonitorCounterDataAMD");
            return false;
        }
    }

    bool Gles::callGlGetPerfMonitorCounterInfoAMD(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto pname = stack->pop<GLenum>();
        auto counter = stack->pop<uint32_t>();
        auto group = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfMonitorCounterInfoAMD(%" PRIu32 ", %" PRIu32 ", %u, %p)", group, counter, pname, data);
            if (glGetPerfMonitorCounterInfoAMD != nullptr) {
                glGetPerfMonitorCounterInfoAMD(group, counter, pname, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorCounterInfoAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfMonitorCounterInfoAMD");
            return false;
        }
    }

    bool Gles::callGlGetPerfMonitorCounterStringAMD(Stack* stack, bool pushReturn) {
        auto counterString = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto counter = stack->pop<uint32_t>();
        auto group = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfMonitorCounterStringAMD(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)", group, counter, bufSize, length, counterString);
            if (glGetPerfMonitorCounterStringAMD != nullptr) {
                glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorCounterStringAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfMonitorCounterStringAMD");
            return false;
        }
    }

    bool Gles::callGlGetPerfMonitorCountersAMD(Stack* stack, bool pushReturn) {
        auto counters = stack->pop<GLuint*>();
        auto counterSize = stack->pop<int32_t>();
        auto maxActiveCounters = stack->pop<GLint*>();
        auto numCounters = stack->pop<GLint*>();
        auto group = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfMonitorCountersAMD(%" PRIu32 ", %p, %p, %" PRId32 ", %p)", group, numCounters, maxActiveCounters, counterSize, counters);
            if (glGetPerfMonitorCountersAMD != nullptr) {
                glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorCountersAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfMonitorCountersAMD");
            return false;
        }
    }

    bool Gles::callGlGetPerfMonitorGroupStringAMD(Stack* stack, bool pushReturn) {
        auto groupString = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto group = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfMonitorGroupStringAMD(%" PRIu32 ", %" PRId32 ", %p, %p)", group, bufSize, length, groupString);
            if (glGetPerfMonitorGroupStringAMD != nullptr) {
                glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorGroupStringAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfMonitorGroupStringAMD");
            return false;
        }
    }

    bool Gles::callGlGetPerfMonitorGroupsAMD(Stack* stack, bool pushReturn) {
        auto groups = stack->pop<GLuint*>();
        auto groupsSize = stack->pop<int32_t>();
        auto numGroups = stack->pop<GLint*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfMonitorGroupsAMD(%p, %" PRId32 ", %p)", numGroups, groupsSize, groups);
            if (glGetPerfMonitorGroupsAMD != nullptr) {
                glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorGroupsAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfMonitorGroupsAMD");
            return false;
        }
    }

    bool Gles::callGlGetPerfQueryDataINTEL(Stack* stack, bool pushReturn) {
        auto bytesWritten = stack->pop<GLuint*>();
        auto data = stack->pop<GLvoid*>();
        auto dataSize = stack->pop<int32_t>();
        auto flag = stack->pop<uint32_t>();
        auto queryHandle = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfQueryDataINTEL(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)", queryHandle, flag, dataSize, data, bytesWritten);
            if (glGetPerfQueryDataINTEL != nullptr) {
                glGetPerfQueryDataINTEL(queryHandle, flag, dataSize, data, bytesWritten);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfQueryDataINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfQueryDataINTEL");
            return false;
        }
    }

    bool Gles::callGlGetPerfQueryIdByNameINTEL(Stack* stack, bool pushReturn) {
        auto queryId = stack->pop<GLuint*>();
        auto queryName = stack->pop<GLchar*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfQueryIdByNameINTEL(%p, %p)", queryName, queryId);
            if (glGetPerfQueryIdByNameINTEL != nullptr) {
                glGetPerfQueryIdByNameINTEL(queryName, queryId);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfQueryIdByNameINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfQueryIdByNameINTEL");
            return false;
        }
    }

    bool Gles::callGlGetPerfQueryInfoINTEL(Stack* stack, bool pushReturn) {
        auto capsMask = stack->pop<GLuint*>();
        auto noInstances = stack->pop<GLuint*>();
        auto noCounters = stack->pop<GLuint*>();
        auto dataSize = stack->pop<GLuint*>();
        auto queryName = stack->pop<GLchar*>();
        auto queryNameLength = stack->pop<uint32_t>();
        auto queryId = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetPerfQueryInfoINTEL(%" PRIu32 ", %" PRIu32 ", %p, %p, %p, %p, %p)", queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
            if (glGetPerfQueryInfoINTEL != nullptr) {
                glGetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetPerfQueryInfoINTEL");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetPerfQueryInfoINTEL");
            return false;
        }
    }

    bool Gles::callGlGetProgramBinaryOES(Stack* stack, bool pushReturn) {
        auto binary = stack->pop<void*>();
        auto binary_format = stack->pop<GLenum*>();
        auto bytes_written = stack->pop<GLsizei*>();
        auto buffer_size = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramBinaryOES(%" PRIu32 ", %" PRId32 ", %p, %p, %p)", program, buffer_size, bytes_written, binary_format, binary);
            if (glGetProgramBinaryOES != nullptr) {
                glGetProgramBinaryOES(program, buffer_size, bytes_written, binary_format, binary);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramBinaryOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramBinaryOES");
            return false;
        }
    }

    bool Gles::callGlGetProgramPipelineInfoLogEXT(Stack* stack, bool pushReturn) {
        auto infoLog = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramPipelineInfoLogEXT(%" PRIu32 ", %" PRId32 ", %p, %p)", pipeline, bufSize, length, infoLog);
            if (glGetProgramPipelineInfoLogEXT != nullptr) {
                glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineInfoLogEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramPipelineInfoLogEXT");
            return false;
        }
    }

    bool Gles::callGlGetProgramPipelineivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramPipelineivEXT(%" PRIu32 ", %u, %p)", pipeline, pname, params);
            if (glGetProgramPipelineivEXT != nullptr) {
                glGetProgramPipelineivEXT(pipeline, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramPipelineivEXT");
            return false;
        }
    }

    bool Gles::callGlGetProgramResourceLocationIndexEXT(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramResourceLocationIndexEXT(%" PRIu32 ", %u, %s)", program, programInterface, name);
            if (glGetProgramResourceLocationIndexEXT != nullptr) {
                GLint return_value = glGetProgramResourceLocationIndexEXT(program, programInterface, name);
                GAPID_INFO("Returned: %" PRId32 "", return_value);
                if (pushReturn) {
                    stack->push<GLint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceLocationIndexEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramResourceLocationIndexEXT");
            return false;
        }
    }

    bool Gles::callGlGetProgramResourcefvNV(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto props = stack->pop<GLenum*>();
        auto propCount = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramResourcefvNV(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %p, %p)", program, programInterface, index, propCount, props, bufSize, length, params);
            if (glGetProgramResourcefvNV != nullptr) {
                glGetProgramResourcefvNV(program, programInterface, index, propCount, props, bufSize, length, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramResourcefvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramResourcefvNV");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjecti64vEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint64*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjecti64vEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjecti64vEXT != nullptr) {
                glGetQueryObjecti64vEXT(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjecti64vEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjecti64vEXT");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjectivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjectivEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjectivEXT != nullptr) {
                glGetQueryObjectivEXT(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjectivEXT");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjectui64vEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint64*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjectui64vEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjectui64vEXT != nullptr) {
                glGetQueryObjectui64vEXT(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectui64vEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjectui64vEXT");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjectuivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjectuivEXT(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjectuivEXT != nullptr) {
                glGetQueryObjectuivEXT(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectuivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjectuivEXT");
            return false;
        }
    }

    bool Gles::callGlGetQueryivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryivEXT(%u, %u, %p)", target, parameter, value);
            if (glGetQueryivEXT != nullptr) {
                glGetQueryivEXT(target, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryivEXT");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterIivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterIivOES(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterIivOES != nullptr) {
                glGetSamplerParameterIivOES(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterIivOES");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterIuivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterIuivOES(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterIuivOES != nullptr) {
                glGetSamplerParameterIuivOES(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIuivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterIuivOES");
            return false;
        }
    }

    bool Gles::callGlGetSyncivAPPLE(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSyncivAPPLE(%p, %u, %" PRId32 ", %p, %p)", sync, pname, bufSize, length, values);
            if (glGetSyncivAPPLE != nullptr) {
                glGetSyncivAPPLE(sync, pname, bufSize, length, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSyncivAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSyncivAPPLE");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterIivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterIivOES(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterIivOES != nullptr) {
                glGetTexParameterIivOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterIivOES");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterIuivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterIuivOES(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterIuivOES != nullptr) {
                glGetTexParameterIuivOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIuivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterIuivOES");
            return false;
        }
    }

    bool Gles::callGlGetTextureHandleNV(Stack* stack, bool pushReturn) {
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTextureHandleNV(%" PRIu32 ")", texture);
            if (glGetTextureHandleNV != nullptr) {
                GLuint64 return_value = glGetTextureHandleNV(texture);
                GAPID_INFO("Returned: %" PRIu64 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint64>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTextureHandleNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTextureHandleNV");
            return false;
        }
    }

    bool Gles::callGlGetTextureSamplerHandleNV(Stack* stack, bool pushReturn) {
        auto sampler = stack->pop<uint32_t>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTextureSamplerHandleNV(%" PRIu32 ", %" PRIu32 ")", texture, sampler);
            if (glGetTextureSamplerHandleNV != nullptr) {
                GLuint64 return_value = glGetTextureSamplerHandleNV(texture, sampler);
                GAPID_INFO("Returned: %" PRIu64 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint64>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTextureSamplerHandleNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTextureSamplerHandleNV");
            return false;
        }
    }

    bool Gles::callGlGetTranslatedShaderSourceANGLE(Stack* stack, bool pushReturn) {
        auto source = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufsize = stack->pop<int32_t>();
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTranslatedShaderSourceANGLE(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, bufsize, length, source);
            if (glGetTranslatedShaderSourceANGLE != nullptr) {
                glGetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTranslatedShaderSourceANGLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTranslatedShaderSourceANGLE");
            return false;
        }
    }

    bool Gles::callGlGetnUniformfvEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformfvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
            if (glGetnUniformfvEXT != nullptr) {
                glGetnUniformfvEXT(program, location, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformfvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformfvEXT");
            return false;
        }
    }

    bool Gles::callGlGetnUniformfvKHR(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformfvKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
            if (glGetnUniformfvKHR != nullptr) {
                glGetnUniformfvKHR(program, location, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformfvKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformfvKHR");
            return false;
        }
    }

    bool Gles::callGlGetnUniformivEXT(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
            if (glGetnUniformivEXT != nullptr) {
                glGetnUniformivEXT(program, location, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformivEXT");
            return false;
        }
    }

    bool Gles::callGlGetnUniformivKHR(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformivKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
            if (glGetnUniformivKHR != nullptr) {
                glGetnUniformivKHR(program, location, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformivKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformivKHR");
            return false;
        }
    }

    bool Gles::callGlGetnUniformuivKHR(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformuivKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, params);
            if (glGetnUniformuivKHR != nullptr) {
                glGetnUniformuivKHR(program, location, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformuivKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformuivKHR");
            return false;
        }
    }

    bool Gles::callGlInsertEventMarkerEXT(Stack* stack, bool pushReturn) {
        auto marker = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glInsertEventMarkerEXT(%" PRId32 ", %p)", length, marker);
            if (glInsertEventMarkerEXT != nullptr) {
                glInsertEventMarkerEXT(length, marker);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glInsertEventMarkerEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glInsertEventMarkerEXT");
            return false;
        }
    }

    bool Gles::callGlInterpolatePathsNV(Stack* stack, bool pushReturn) {
        auto weight = stack->pop<float>();
        auto pathB = stack->pop<uint32_t>();
        auto pathA = stack->pop<uint32_t>();
        auto resultPath = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glInterpolatePathsNV(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %f)", resultPath, pathA, pathB, weight);
            if (glInterpolatePathsNV != nullptr) {
                glInterpolatePathsNV(resultPath, pathA, pathB, weight);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glInterpolatePathsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glInterpolatePathsNV");
            return false;
        }
    }

    bool Gles::callGlIsEnablediNV(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glIsEnablediNV(%u, %" PRIu32 ")", target, index);
            if (glIsEnablediNV != nullptr) {
                GLboolean return_value = glIsEnablediNV(target, index);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsEnablediNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsEnablediNV");
            return false;
        }
    }

    bool Gles::callGlIsEnablediOES(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glIsEnablediOES(%u, %" PRIu32 ")", target, index);
            if (glIsEnablediOES != nullptr) {
                GLboolean return_value = glIsEnablediOES(target, index);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsEnablediOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsEnablediOES");
            return false;
        }
    }

    bool Gles::callGlIsFenceNV(Stack* stack, bool pushReturn) {
        auto fence = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsFenceNV(%" PRIu32 ")", fence);
            if (glIsFenceNV != nullptr) {
                GLboolean return_value = glIsFenceNV(fence);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsFenceNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsFenceNV");
            return false;
        }
    }

    bool Gles::callGlIsImageHandleResidentNV(Stack* stack, bool pushReturn) {
        auto handle = stack->pop<uint64_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsImageHandleResidentNV(%" PRIu64 ")", handle);
            if (glIsImageHandleResidentNV != nullptr) {
                GLboolean return_value = glIsImageHandleResidentNV(handle);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsImageHandleResidentNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsImageHandleResidentNV");
            return false;
        }
    }

    bool Gles::callGlIsPathNV(Stack* stack, bool pushReturn) {
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsPathNV(%" PRIu32 ")", path);
            if (glIsPathNV != nullptr) {
                GLboolean return_value = glIsPathNV(path);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsPathNV");
            return false;
        }
    }

    bool Gles::callGlIsPointInFillPathNV(Stack* stack, bool pushReturn) {
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        auto mask = stack->pop<uint32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsPointInFillPathNV(%" PRIu32 ", %" PRIu32 ", %f, %f)", path, mask, x, y);
            if (glIsPointInFillPathNV != nullptr) {
                GLboolean return_value = glIsPointInFillPathNV(path, mask, x, y);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsPointInFillPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsPointInFillPathNV");
            return false;
        }
    }

    bool Gles::callGlIsPointInStrokePathNV(Stack* stack, bool pushReturn) {
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsPointInStrokePathNV(%" PRIu32 ", %f, %f)", path, x, y);
            if (glIsPointInStrokePathNV != nullptr) {
                GLboolean return_value = glIsPointInStrokePathNV(path, x, y);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsPointInStrokePathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsPointInStrokePathNV");
            return false;
        }
    }

    bool Gles::callGlIsProgramPipelineEXT(Stack* stack, bool pushReturn) {
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsProgramPipelineEXT(%" PRIu32 ")", pipeline);
            if (glIsProgramPipelineEXT != nullptr) {
                GLboolean return_value = glIsProgramPipelineEXT(pipeline);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsProgramPipelineEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsProgramPipelineEXT");
            return false;
        }
    }

    bool Gles::callGlIsQueryEXT(Stack* stack, bool pushReturn) {
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsQueryEXT(%" PRIu32 ")", query);
            if (glIsQueryEXT != nullptr) {
                GLboolean return_value = glIsQueryEXT(query);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsQueryEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsQueryEXT");
            return false;
        }
    }

    bool Gles::callGlIsSyncAPPLE(Stack* stack, bool pushReturn) {
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glIsSyncAPPLE(%p)", sync);
            if (glIsSyncAPPLE != nullptr) {
                GLboolean return_value = glIsSyncAPPLE(sync);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsSyncAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsSyncAPPLE");
            return false;
        }
    }

    bool Gles::callGlIsTextureHandleResidentNV(Stack* stack, bool pushReturn) {
        auto handle = stack->pop<uint64_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsTextureHandleResidentNV(%" PRIu64 ")", handle);
            if (glIsTextureHandleResidentNV != nullptr) {
                GLboolean return_value = glIsTextureHandleResidentNV(handle);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsTextureHandleResidentNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsTextureHandleResidentNV");
            return false;
        }
    }

    bool Gles::callGlIsVertexArrayOES(Stack* stack, bool pushReturn) {
        auto array = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsVertexArrayOES(%" PRIu32 ")", array);
            if (glIsVertexArrayOES != nullptr) {
                GLboolean return_value = glIsVertexArrayOES(array);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsVertexArrayOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsVertexArrayOES");
            return false;
        }
    }

    bool Gles::callGlLabelObjectEXT(Stack* stack, bool pushReturn) {
        auto label = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        auto object = stack->pop<uint32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLabelObjectEXT(%u, %" PRIu32 ", %" PRId32 ", %p)", type, object, length, label);
            if (glLabelObjectEXT != nullptr) {
                glLabelObjectEXT(type, object, length, label);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLabelObjectEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLabelObjectEXT");
            return false;
        }
    }

    bool Gles::callGlMakeImageHandleNonResidentNV(Stack* stack, bool pushReturn) {
        auto handle = stack->pop<uint64_t>();
        if (stack->isValid()) {
            GAPID_INFO("glMakeImageHandleNonResidentNV(%" PRIu64 ")", handle);
            if (glMakeImageHandleNonResidentNV != nullptr) {
                glMakeImageHandleNonResidentNV(handle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMakeImageHandleNonResidentNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMakeImageHandleNonResidentNV");
            return false;
        }
    }

    bool Gles::callGlMakeImageHandleResidentNV(Stack* stack, bool pushReturn) {
        auto access = stack->pop<GLenum>();
        auto handle = stack->pop<uint64_t>();
        if (stack->isValid()) {
            GAPID_INFO("glMakeImageHandleResidentNV(%" PRIu64 ", %u)", handle, access);
            if (glMakeImageHandleResidentNV != nullptr) {
                glMakeImageHandleResidentNV(handle, access);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMakeImageHandleResidentNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMakeImageHandleResidentNV");
            return false;
        }
    }

    bool Gles::callGlMakeTextureHandleNonResidentNV(Stack* stack, bool pushReturn) {
        auto handle = stack->pop<uint64_t>();
        if (stack->isValid()) {
            GAPID_INFO("glMakeTextureHandleNonResidentNV(%" PRIu64 ")", handle);
            if (glMakeTextureHandleNonResidentNV != nullptr) {
                glMakeTextureHandleNonResidentNV(handle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMakeTextureHandleNonResidentNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMakeTextureHandleNonResidentNV");
            return false;
        }
    }

    bool Gles::callGlMakeTextureHandleResidentNV(Stack* stack, bool pushReturn) {
        auto handle = stack->pop<uint64_t>();
        if (stack->isValid()) {
            GAPID_INFO("glMakeTextureHandleResidentNV(%" PRIu64 ")", handle);
            if (glMakeTextureHandleResidentNV != nullptr) {
                glMakeTextureHandleResidentNV(handle);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMakeTextureHandleResidentNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMakeTextureHandleResidentNV");
            return false;
        }
    }

    bool Gles::callGlMapBufferOES(Stack* stack, bool pushReturn) {
        auto access = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMapBufferOES(%u, %u)", target, access);
            if (glMapBufferOES != nullptr) {
                void* return_value = glMapBufferOES(target, access);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<void*>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMapBufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMapBufferOES");
            return false;
        }
    }

    bool Gles::callGlMapBufferRangeEXT(Stack* stack, bool pushReturn) {
        auto access = stack->pop<GLbitfield>();
        auto length = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMapBufferRangeEXT(%u, %" PRId32 ", %" PRId32 ", %u)", target, offset, length, access);
            if (glMapBufferRangeEXT != nullptr) {
                void* return_value = glMapBufferRangeEXT(target, offset, length, access);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<void*>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMapBufferRangeEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMapBufferRangeEXT");
            return false;
        }
    }

    bool Gles::callGlMatrixLoad3x2fNV(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        auto matrixMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixLoad3x2fNV(%u, %p)", matrixMode, m);
            if (glMatrixLoad3x2fNV != nullptr) {
                glMatrixLoad3x2fNV(matrixMode, m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixLoad3x2fNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixLoad3x2fNV");
            return false;
        }
    }

    bool Gles::callGlMatrixLoad3x3fNV(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        auto matrixMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixLoad3x3fNV(%u, %p)", matrixMode, m);
            if (glMatrixLoad3x3fNV != nullptr) {
                glMatrixLoad3x3fNV(matrixMode, m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixLoad3x3fNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixLoad3x3fNV");
            return false;
        }
    }

    bool Gles::callGlMatrixLoadTranspose3x3fNV(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        auto matrixMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixLoadTranspose3x3fNV(%u, %p)", matrixMode, m);
            if (glMatrixLoadTranspose3x3fNV != nullptr) {
                glMatrixLoadTranspose3x3fNV(matrixMode, m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixLoadTranspose3x3fNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixLoadTranspose3x3fNV");
            return false;
        }
    }

    bool Gles::callGlMatrixMult3x2fNV(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        auto matrixMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixMult3x2fNV(%u, %p)", matrixMode, m);
            if (glMatrixMult3x2fNV != nullptr) {
                glMatrixMult3x2fNV(matrixMode, m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixMult3x2fNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixMult3x2fNV");
            return false;
        }
    }

    bool Gles::callGlMatrixMult3x3fNV(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        auto matrixMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixMult3x3fNV(%u, %p)", matrixMode, m);
            if (glMatrixMult3x3fNV != nullptr) {
                glMatrixMult3x3fNV(matrixMode, m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixMult3x3fNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixMult3x3fNV");
            return false;
        }
    }

    bool Gles::callGlMatrixMultTranspose3x3fNV(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        auto matrixMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixMultTranspose3x3fNV(%u, %p)", matrixMode, m);
            if (glMatrixMultTranspose3x3fNV != nullptr) {
                glMatrixMultTranspose3x3fNV(matrixMode, m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixMultTranspose3x3fNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixMultTranspose3x3fNV");
            return false;
        }
    }

    bool Gles::callGlMultiDrawArraysEXT(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto count = stack->pop<GLsizei*>();
        auto first = stack->pop<GLint*>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiDrawArraysEXT(%u, %p, %p, %" PRId32 ")", mode, first, count, primcount);
            if (glMultiDrawArraysEXT != nullptr) {
                glMultiDrawArraysEXT(mode, first, count, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiDrawArraysEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiDrawArraysEXT");
            return false;
        }
    }

    bool Gles::callGlMultiDrawArraysIndirectEXT(Stack* stack, bool pushReturn) {
        auto stride = stack->pop<int32_t>();
        auto drawcount = stack->pop<int32_t>();
        auto indirect = stack->pop<void*>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiDrawArraysIndirectEXT(%u, %p, %" PRId32 ", %" PRId32 ")", mode, indirect, drawcount, stride);
            if (glMultiDrawArraysIndirectEXT != nullptr) {
                glMultiDrawArraysIndirectEXT(mode, indirect, drawcount, stride);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiDrawArraysIndirectEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiDrawArraysIndirectEXT");
            return false;
        }
    }

    bool Gles::callGlMultiDrawElementsBaseVertexEXT(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<GLint*>();
        auto primcount = stack->pop<int32_t>();
        auto indices = stack->pop<void**>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<GLsizei*>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiDrawElementsBaseVertexEXT(%u, %p, %u, %p, %" PRId32 ", %p)", mode, count, type, indices, primcount, basevertex);
            if (glMultiDrawElementsBaseVertexEXT != nullptr) {
                glMultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiDrawElementsBaseVertexEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiDrawElementsBaseVertexEXT");
            return false;
        }
    }

    bool Gles::callGlMultiDrawElementsBaseVertexOES(Stack* stack, bool pushReturn) {
        auto basevertex = stack->pop<GLint*>();
        auto primcount = stack->pop<int32_t>();
        auto indices = stack->pop<void**>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<GLsizei*>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiDrawElementsBaseVertexOES(%u, %p, %u, %p, %" PRId32 ", %p)", mode, count, type, indices, primcount, basevertex);
            if (glMultiDrawElementsBaseVertexOES != nullptr) {
                glMultiDrawElementsBaseVertexOES(mode, count, type, indices, primcount, basevertex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiDrawElementsBaseVertexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiDrawElementsBaseVertexOES");
            return false;
        }
    }

    bool Gles::callGlMultiDrawElementsEXT(Stack* stack, bool pushReturn) {
        auto primcount = stack->pop<int32_t>();
        auto indices = stack->pop<void**>();
        auto type = stack->pop<GLenum>();
        auto count = stack->pop<GLsizei*>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiDrawElementsEXT(%u, %p, %u, %p, %" PRId32 ")", mode, count, type, indices, primcount);
            if (glMultiDrawElementsEXT != nullptr) {
                glMultiDrawElementsEXT(mode, count, type, indices, primcount);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiDrawElementsEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiDrawElementsEXT");
            return false;
        }
    }

    bool Gles::callGlMultiDrawElementsIndirectEXT(Stack* stack, bool pushReturn) {
        auto stride = stack->pop<int32_t>();
        auto drawcount = stack->pop<int32_t>();
        auto indirect = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiDrawElementsIndirectEXT(%u, %u, %p, %" PRId32 ", %" PRId32 ")", mode, type, indirect, drawcount, stride);
            if (glMultiDrawElementsIndirectEXT != nullptr) {
                glMultiDrawElementsIndirectEXT(mode, type, indirect, drawcount, stride);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiDrawElementsIndirectEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiDrawElementsIndirectEXT");
            return false;
        }
    }

    bool Gles::callGlNamedFramebufferSampleLocationsfvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto start = stack->pop<uint32_t>();
        auto framebuffer = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glNamedFramebufferSampleLocationsfvNV(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p)", framebuffer, start, count, v);
            if (glNamedFramebufferSampleLocationsfvNV != nullptr) {
                glNamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glNamedFramebufferSampleLocationsfvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glNamedFramebufferSampleLocationsfvNV");
            return false;
        }
    }

    bool Gles::callGlPatchParameteriOES(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPatchParameteriOES(%u, %" PRId32 ")", pname, value);
            if (glPatchParameteriOES != nullptr) {
                glPatchParameteriOES(pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPatchParameteriOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPatchParameteriOES");
            return false;
        }
    }

    bool Gles::callGlPathCommandsNV(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<void*>();
        auto coordType = stack->pop<GLenum>();
        auto numCoords = stack->pop<int32_t>();
        auto commands = stack->pop<GLubyte*>();
        auto numCommands = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathCommandsNV(%" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %u, %p)", path, numCommands, commands, numCoords, coordType, coords);
            if (glPathCommandsNV != nullptr) {
                glPathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathCommandsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathCommandsNV");
            return false;
        }
    }

    bool Gles::callGlPathCoordsNV(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<void*>();
        auto coordType = stack->pop<GLenum>();
        auto numCoords = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathCoordsNV(%" PRIu32 ", %" PRId32 ", %u, %p)", path, numCoords, coordType, coords);
            if (glPathCoordsNV != nullptr) {
                glPathCoordsNV(path, numCoords, coordType, coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathCoordsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathCoordsNV");
            return false;
        }
    }

    bool Gles::callGlPathCoverDepthFuncNV(Stack* stack, bool pushReturn) {
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPathCoverDepthFuncNV(%u)", func);
            if (glPathCoverDepthFuncNV != nullptr) {
                glPathCoverDepthFuncNV(func);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathCoverDepthFuncNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathCoverDepthFuncNV");
            return false;
        }
    }

    bool Gles::callGlPathDashArrayNV(Stack* stack, bool pushReturn) {
        auto dashArray = stack->pop<GLfloat*>();
        auto dashCount = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathDashArrayNV(%" PRIu32 ", %" PRId32 ", %p)", path, dashCount, dashArray);
            if (glPathDashArrayNV != nullptr) {
                glPathDashArrayNV(path, dashCount, dashArray);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathDashArrayNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathDashArrayNV");
            return false;
        }
    }

    bool Gles::callGlPathGlyphIndexArrayNV(Stack* stack, bool pushReturn) {
        auto emScale = stack->pop<float>();
        auto pathParameterTemplate = stack->pop<uint32_t>();
        auto numGlyphs = stack->pop<int32_t>();
        auto firstGlyphIndex = stack->pop<uint32_t>();
        auto fontStyle = stack->pop<GLbitfield>();
        auto fontName = stack->pop<void*>();
        auto fontTarget = stack->pop<GLenum>();
        auto firstPathName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathGlyphIndexArrayNV(%" PRIu32 ", %u, %p, %u, %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %f)", firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
            if (glPathGlyphIndexArrayNV != nullptr) {
                GLenum return_value = glPathGlyphIndexArrayNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathGlyphIndexArrayNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathGlyphIndexArrayNV");
            return false;
        }
    }

    bool Gles::callGlPathGlyphIndexRangeNV(Stack* stack, bool pushReturn) {
        auto baseAndCount = stack->pop<uint32_t>();
        auto emScale = stack->pop<float>();
        auto pathParameterTemplate = stack->pop<uint32_t>();
        auto fontStyle = stack->pop<GLbitfield>();
        auto fontName = stack->pop<void*>();
        auto fontTarget = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPathGlyphIndexRangeNV(%u, %p, %u, %" PRIu32 ", %f, %" PRIu32 ")", fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
            if (glPathGlyphIndexRangeNV != nullptr) {
                GLenum return_value = glPathGlyphIndexRangeNV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathGlyphIndexRangeNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathGlyphIndexRangeNV");
            return false;
        }
    }

    bool Gles::callGlPathGlyphRangeNV(Stack* stack, bool pushReturn) {
        auto emScale = stack->pop<float>();
        auto pathParameterTemplate = stack->pop<uint32_t>();
        auto handleMissingGlyphs = stack->pop<GLenum>();
        auto numGlyphs = stack->pop<int32_t>();
        auto firstGlyph = stack->pop<uint32_t>();
        auto fontStyle = stack->pop<GLbitfield>();
        auto fontName = stack->pop<void*>();
        auto fontTarget = stack->pop<GLenum>();
        auto firstPathName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathGlyphRangeNV(%" PRIu32 ", %u, %p, %u, %" PRIu32 ", %" PRId32 ", %u, %" PRIu32 ", %f)", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
            if (glPathGlyphRangeNV != nullptr) {
                glPathGlyphRangeNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathGlyphRangeNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathGlyphRangeNV");
            return false;
        }
    }

    bool Gles::callGlPathGlyphsNV(Stack* stack, bool pushReturn) {
        auto emScale = stack->pop<float>();
        auto pathParameterTemplate = stack->pop<uint32_t>();
        auto handleMissingGlyphs = stack->pop<GLenum>();
        auto charcodes = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto numGlyphs = stack->pop<int32_t>();
        auto fontStyle = stack->pop<GLbitfield>();
        auto fontName = stack->pop<void*>();
        auto fontTarget = stack->pop<GLenum>();
        auto firstPathName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathGlyphsNV(%" PRIu32 ", %u, %p, %u, %" PRId32 ", %u, %p, %u, %" PRIu32 ", %f)", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
            if (glPathGlyphsNV != nullptr) {
                glPathGlyphsNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathGlyphsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathGlyphsNV");
            return false;
        }
    }

    bool Gles::callGlPathMemoryGlyphIndexArrayNV(Stack* stack, bool pushReturn) {
        auto emScale = stack->pop<float>();
        auto pathParameterTemplate = stack->pop<uint32_t>();
        auto numGlyphs = stack->pop<int32_t>();
        auto firstGlyphIndex = stack->pop<uint32_t>();
        auto faceIndex = stack->pop<int32_t>();
        auto fontData = stack->pop<void*>();
        auto fontSize = stack->pop<int32_t>();
        auto fontTarget = stack->pop<GLenum>();
        auto firstPathName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathMemoryGlyphIndexArrayNV(%" PRIu32 ", %u, %" PRId32 ", %p, %" PRId32 ", %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %f)", firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
            if (glPathMemoryGlyphIndexArrayNV != nullptr) {
                GLenum return_value = glPathMemoryGlyphIndexArrayNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathMemoryGlyphIndexArrayNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathMemoryGlyphIndexArrayNV");
            return false;
        }
    }

    bool Gles::callGlPathParameterfNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathParameterfNV(%" PRIu32 ", %u, %f)", path, pname, value);
            if (glPathParameterfNV != nullptr) {
                glPathParameterfNV(path, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathParameterfNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathParameterfNV");
            return false;
        }
    }

    bool Gles::callGlPathParameterfvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathParameterfvNV(%" PRIu32 ", %u, %p)", path, pname, value);
            if (glPathParameterfvNV != nullptr) {
                glPathParameterfvNV(path, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathParameterfvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathParameterfvNV");
            return false;
        }
    }

    bool Gles::callGlPathParameteriNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathParameteriNV(%" PRIu32 ", %u, %" PRId32 ")", path, pname, value);
            if (glPathParameteriNV != nullptr) {
                glPathParameteriNV(path, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathParameteriNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathParameteriNV");
            return false;
        }
    }

    bool Gles::callGlPathParameterivNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathParameterivNV(%" PRIu32 ", %u, %p)", path, pname, value);
            if (glPathParameterivNV != nullptr) {
                glPathParameterivNV(path, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathParameterivNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathParameterivNV");
            return false;
        }
    }

    bool Gles::callGlPathStencilDepthOffsetNV(Stack* stack, bool pushReturn) {
        auto units = stack->pop<float>();
        auto factor = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glPathStencilDepthOffsetNV(%f, %f)", factor, units);
            if (glPathStencilDepthOffsetNV != nullptr) {
                glPathStencilDepthOffsetNV(factor, units);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathStencilDepthOffsetNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathStencilDepthOffsetNV");
            return false;
        }
    }

    bool Gles::callGlPathStencilFuncNV(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        auto ref = stack->pop<int32_t>();
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPathStencilFuncNV(%u, %" PRId32 ", %" PRIu32 ")", func, ref, mask);
            if (glPathStencilFuncNV != nullptr) {
                glPathStencilFuncNV(func, ref, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathStencilFuncNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathStencilFuncNV");
            return false;
        }
    }

    bool Gles::callGlPathStringNV(Stack* stack, bool pushReturn) {
        auto pathString = stack->pop<void*>();
        auto length = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathStringNV(%" PRIu32 ", %u, %" PRId32 ", %p)", path, format, length, pathString);
            if (glPathStringNV != nullptr) {
                glPathStringNV(path, format, length, pathString);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathStringNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathStringNV");
            return false;
        }
    }

    bool Gles::callGlPathSubCommandsNV(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<void*>();
        auto coordType = stack->pop<GLenum>();
        auto numCoords = stack->pop<int32_t>();
        auto commands = stack->pop<GLubyte*>();
        auto numCommands = stack->pop<int32_t>();
        auto commandsToDelete = stack->pop<int32_t>();
        auto commandStart = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathSubCommandsNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p, %" PRId32 ", %u, %p)", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
            if (glPathSubCommandsNV != nullptr) {
                glPathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathSubCommandsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathSubCommandsNV");
            return false;
        }
    }

    bool Gles::callGlPathSubCoordsNV(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<void*>();
        auto coordType = stack->pop<GLenum>();
        auto numCoords = stack->pop<int32_t>();
        auto coordStart = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPathSubCoordsNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %u, %p)", path, coordStart, numCoords, coordType, coords);
            if (glPathSubCoordsNV != nullptr) {
                glPathSubCoordsNV(path, coordStart, numCoords, coordType, coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPathSubCoordsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPathSubCoordsNV");
            return false;
        }
    }

    bool Gles::callGlPointAlongPathNV(Stack* stack, bool pushReturn) {
        auto tangentY = stack->pop<GLfloat*>();
        auto tangentX = stack->pop<GLfloat*>();
        auto y = stack->pop<GLfloat*>();
        auto x = stack->pop<GLfloat*>();
        auto distance = stack->pop<float>();
        auto numSegments = stack->pop<int32_t>();
        auto startSegment = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPointAlongPathNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %f, %p, %p, %p, %p)", path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
            if (glPointAlongPathNV != nullptr) {
                GLboolean return_value = glPointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointAlongPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointAlongPathNV");
            return false;
        }
    }

    bool Gles::callGlPolygonModeNV(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPolygonModeNV(%u, %u)", face, mode);
            if (glPolygonModeNV != nullptr) {
                glPolygonModeNV(face, mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPolygonModeNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPolygonModeNV");
            return false;
        }
    }

    bool Gles::callGlPopGroupMarkerEXT(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glPopGroupMarkerEXT()");
            if (glPopGroupMarkerEXT != nullptr) {
                glPopGroupMarkerEXT();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPopGroupMarkerEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPopGroupMarkerEXT");
            return false;
        }
    }

    bool Gles::callGlPrimitiveBoundingBoxOES(Stack* stack, bool pushReturn) {
        auto maxW = stack->pop<float>();
        auto maxZ = stack->pop<float>();
        auto maxY = stack->pop<float>();
        auto maxX = stack->pop<float>();
        auto minW = stack->pop<float>();
        auto minZ = stack->pop<float>();
        auto minY = stack->pop<float>();
        auto minX = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glPrimitiveBoundingBoxOES(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            if (glPrimitiveBoundingBoxOES != nullptr) {
                glPrimitiveBoundingBoxOES(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPrimitiveBoundingBoxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPrimitiveBoundingBoxOES");
            return false;
        }
    }

    bool Gles::callGlProgramBinaryOES(Stack* stack, bool pushReturn) {
        auto binary_size = stack->pop<int32_t>();
        auto binary = stack->pop<void*>();
        auto binary_format = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramBinaryOES(%" PRIu32 ", %u, %p, %" PRId32 ")", program, binary_format, binary, binary_size);
            if (glProgramBinaryOES != nullptr) {
                glProgramBinaryOES(program, binary_format, binary, binary_size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramBinaryOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramBinaryOES");
            return false;
        }
    }

    bool Gles::callGlProgramParameteriEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramParameteriEXT(%" PRIu32 ", %u, %" PRId32 ")", program, pname, value);
            if (glProgramParameteriEXT != nullptr) {
                glProgramParameteriEXT(program, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramParameteriEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramParameteriEXT");
            return false;
        }
    }

    bool Gles::callGlProgramPathFragmentInputGenNV(Stack* stack, bool pushReturn) {
        auto coeffs = stack->pop<GLfloat*>();
        auto components = stack->pop<int32_t>();
        auto genMode = stack->pop<GLenum>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramPathFragmentInputGenNV(%" PRIu32 ", %" PRId32 ", %u, %" PRId32 ", %p)", program, location, genMode, components, coeffs);
            if (glProgramPathFragmentInputGenNV != nullptr) {
                glProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramPathFragmentInputGenNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramPathFragmentInputGenNV");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1fEXT(Stack* stack, bool pushReturn) {
        auto v0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1fEXT(%" PRIu32 ", %" PRId32 ", %f)", program, location, v0);
            if (glProgramUniform1fEXT != nullptr) {
                glProgramUniform1fEXT(program, location, v0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1fEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1fEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform1fvEXT != nullptr) {
                glProgramUniform1fvEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1iEXT(Stack* stack, bool pushReturn) {
        auto v0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ")", program, location, v0);
            if (glProgramUniform1iEXT != nullptr) {
                glProgramUniform1iEXT(program, location, v0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1iEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1iEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1ivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform1ivEXT != nullptr) {
                glProgramUniform1ivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1ivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1ivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1uiEXT(Stack* stack, bool pushReturn) {
        auto v0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")", program, location, v0);
            if (glProgramUniform1uiEXT != nullptr) {
                glProgramUniform1uiEXT(program, location, v0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1uiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1uiEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1uivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform1uivEXT != nullptr) {
                glProgramUniform1uivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1uivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1uivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2fEXT(Stack* stack, bool pushReturn) {
        auto v1 = stack->pop<float>();
        auto v0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2fEXT(%" PRIu32 ", %" PRId32 ", %f, %f)", program, location, v0, v1);
            if (glProgramUniform2fEXT != nullptr) {
                glProgramUniform2fEXT(program, location, v0, v1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2fEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2fEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform2fvEXT != nullptr) {
                glProgramUniform2fvEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2iEXT(Stack* stack, bool pushReturn) {
        auto v1 = stack->pop<int32_t>();
        auto v0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, v0, v1);
            if (glProgramUniform2iEXT != nullptr) {
                glProgramUniform2iEXT(program, location, v0, v1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2iEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2iEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2ivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform2ivEXT != nullptr) {
                glProgramUniform2ivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2ivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2ivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2uiEXT(Stack* stack, bool pushReturn) {
        auto v1 = stack->pop<uint32_t>();
        auto v0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ")", program, location, v0, v1);
            if (glProgramUniform2uiEXT != nullptr) {
                glProgramUniform2uiEXT(program, location, v0, v1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2uiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2uiEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2uivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform2uivEXT != nullptr) {
                glProgramUniform2uivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2uivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2uivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3fEXT(Stack* stack, bool pushReturn) {
        auto v2 = stack->pop<float>();
        auto v1 = stack->pop<float>();
        auto v0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3fEXT(%" PRIu32 ", %" PRId32 ", %f, %f, %f)", program, location, v0, v1, v2);
            if (glProgramUniform3fEXT != nullptr) {
                glProgramUniform3fEXT(program, location, v0, v1, v2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3fEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3fEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform3fvEXT != nullptr) {
                glProgramUniform3fvEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3iEXT(Stack* stack, bool pushReturn) {
        auto v2 = stack->pop<int32_t>();
        auto v1 = stack->pop<int32_t>();
        auto v0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, v0, v1, v2);
            if (glProgramUniform3iEXT != nullptr) {
                glProgramUniform3iEXT(program, location, v0, v1, v2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3iEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3iEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3ivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform3ivEXT != nullptr) {
                glProgramUniform3ivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3ivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3ivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3uiEXT(Stack* stack, bool pushReturn) {
        auto v2 = stack->pop<uint32_t>();
        auto v1 = stack->pop<uint32_t>();
        auto v0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, v0, v1, v2);
            if (glProgramUniform3uiEXT != nullptr) {
                glProgramUniform3uiEXT(program, location, v0, v1, v2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3uiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3uiEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3uivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform3uivEXT != nullptr) {
                glProgramUniform3uivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3uivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3uivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4fEXT(Stack* stack, bool pushReturn) {
        auto v3 = stack->pop<float>();
        auto v2 = stack->pop<float>();
        auto v1 = stack->pop<float>();
        auto v0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4fEXT(%" PRIu32 ", %" PRId32 ", %f, %f, %f, %f)", program, location, v0, v1, v2, v3);
            if (glProgramUniform4fEXT != nullptr) {
                glProgramUniform4fEXT(program, location, v0, v1, v2, v3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4fEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4fEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform4fvEXT != nullptr) {
                glProgramUniform4fvEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4iEXT(Stack* stack, bool pushReturn) {
        auto v3 = stack->pop<int32_t>();
        auto v2 = stack->pop<int32_t>();
        auto v1 = stack->pop<int32_t>();
        auto v0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, v0, v1, v2, v3);
            if (glProgramUniform4iEXT != nullptr) {
                glProgramUniform4iEXT(program, location, v0, v1, v2, v3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4iEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4iEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4ivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform4ivEXT != nullptr) {
                glProgramUniform4ivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4ivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4ivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4uiEXT(Stack* stack, bool pushReturn) {
        auto v3 = stack->pop<uint32_t>();
        auto v2 = stack->pop<uint32_t>();
        auto v1 = stack->pop<uint32_t>();
        auto v0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, v0, v1, v2, v3);
            if (glProgramUniform4uiEXT != nullptr) {
                glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4uiEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4uiEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4uivEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, value);
            if (glProgramUniform4uivEXT != nullptr) {
                glProgramUniform4uivEXT(program, location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4uivEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4uivEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformHandleui64NV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<uint64_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformHandleui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ")", program, location, value);
            if (glProgramUniformHandleui64NV != nullptr) {
                glProgramUniformHandleui64NV(program, location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformHandleui64NV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformHandleui64NV");
            return false;
        }
    }

    bool Gles::callGlProgramUniformHandleui64vNV(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint64*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformHandleui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniformHandleui64vNV != nullptr) {
                glProgramUniformHandleui64vNV(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformHandleui64vNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformHandleui64vNV");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix2fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix2fvEXT != nullptr) {
                glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix2fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix2x3fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix2x3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix2x3fvEXT != nullptr) {
                glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2x3fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix2x3fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix2x4fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix2x4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix2x4fvEXT != nullptr) {
                glProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2x4fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix2x4fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix3fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix3fvEXT != nullptr) {
                glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix3fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix3x2fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix3x2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix3x2fvEXT != nullptr) {
                glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3x2fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix3x2fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix3x4fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix3x4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix3x4fvEXT != nullptr) {
                glProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3x4fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix3x4fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix4fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix4fvEXT != nullptr) {
                glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix4fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix4x2fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix4x2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix4x2fvEXT != nullptr) {
                glProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4x2fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix4x2fvEXT");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix4x3fvEXT(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix4x3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, value);
            if (glProgramUniformMatrix4x3fvEXT != nullptr) {
                glProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4x3fvEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix4x3fvEXT");
            return false;
        }
    }

    bool Gles::callGlPushGroupMarkerEXT(Stack* stack, bool pushReturn) {
        auto marker = stack->pop<GLchar*>();
        auto length = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPushGroupMarkerEXT(%" PRId32 ", %p)", length, marker);
            if (glPushGroupMarkerEXT != nullptr) {
                glPushGroupMarkerEXT(length, marker);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPushGroupMarkerEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPushGroupMarkerEXT");
            return false;
        }
    }

    bool Gles::callGlQueryCounterEXT(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glQueryCounterEXT(%" PRIu32 ", %u)", query, target);
            if (glQueryCounterEXT != nullptr) {
                glQueryCounterEXT(query, target);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glQueryCounterEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glQueryCounterEXT");
            return false;
        }
    }

    bool Gles::callGlRasterSamplesEXT(Stack* stack, bool pushReturn) {
        auto fixedsamplelocations = stack->pop<uint8_t>();
        auto samples = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glRasterSamplesEXT(%" PRIu32 ", %" PRIu8 ")", samples, fixedsamplelocations);
            if (glRasterSamplesEXT != nullptr) {
                glRasterSamplesEXT(samples, fixedsamplelocations);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRasterSamplesEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRasterSamplesEXT");
            return false;
        }
    }

    bool Gles::callGlReadBufferIndexedEXT(Stack* stack, bool pushReturn) {
        auto index = stack->pop<int32_t>();
        auto src = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glReadBufferIndexedEXT(%u, %" PRId32 ")", src, index);
            if (glReadBufferIndexedEXT != nullptr) {
                glReadBufferIndexedEXT(src, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadBufferIndexedEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadBufferIndexedEXT");
            return false;
        }
    }

    bool Gles::callGlReadBufferNV(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glReadBufferNV(%u)", mode);
            if (glReadBufferNV != nullptr) {
                glReadBufferNV(mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadBufferNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadBufferNV");
            return false;
        }
    }

    bool Gles::callGlReadnPixelsEXT(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto bufSize = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glReadnPixelsEXT(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %" PRId32 ", %p)", x, y, width, height, format, type, bufSize, data);
            if (glReadnPixelsEXT != nullptr) {
                glReadnPixelsEXT(x, y, width, height, format, type, bufSize, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadnPixelsEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadnPixelsEXT");
            return false;
        }
    }

    bool Gles::callGlReadnPixelsKHR(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto bufSize = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glReadnPixelsKHR(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %" PRId32 ", %p)", x, y, width, height, format, type, bufSize, data);
            if (glReadnPixelsKHR != nullptr) {
                glReadnPixelsKHR(x, y, width, height, format, type, bufSize, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadnPixelsKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadnPixelsKHR");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageMultisampleANGLE(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageMultisampleANGLE(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
            if (glRenderbufferStorageMultisampleANGLE != nullptr) {
                glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageMultisampleANGLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageMultisampleANGLE");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageMultisampleAPPLE(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageMultisampleAPPLE(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
            if (glRenderbufferStorageMultisampleAPPLE != nullptr) {
                glRenderbufferStorageMultisampleAPPLE(target, samples, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageMultisampleAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageMultisampleAPPLE");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageMultisampleEXT(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageMultisampleEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
            if (glRenderbufferStorageMultisampleEXT != nullptr) {
                glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageMultisampleEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageMultisampleEXT");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageMultisampleIMG(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageMultisampleIMG(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
            if (glRenderbufferStorageMultisampleIMG != nullptr) {
                glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageMultisampleIMG");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageMultisampleIMG");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageMultisampleNV(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageMultisampleNV(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
            if (glRenderbufferStorageMultisampleNV != nullptr) {
                glRenderbufferStorageMultisampleNV(target, samples, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageMultisampleNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageMultisampleNV");
            return false;
        }
    }

    bool Gles::callGlResolveDepthValuesNV(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glResolveDepthValuesNV()");
            if (glResolveDepthValuesNV != nullptr) {
                glResolveDepthValuesNV();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glResolveDepthValuesNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glResolveDepthValuesNV");
            return false;
        }
    }

    bool Gles::callGlResolveMultisampleFramebufferAPPLE(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glResolveMultisampleFramebufferAPPLE()");
            if (glResolveMultisampleFramebufferAPPLE != nullptr) {
                glResolveMultisampleFramebufferAPPLE();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glResolveMultisampleFramebufferAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glResolveMultisampleFramebufferAPPLE");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterIivOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterIivOES(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterIivOES != nullptr) {
                glSamplerParameterIivOES(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterIivOES");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterIuivOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterIuivOES(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterIuivOES != nullptr) {
                glSamplerParameterIuivOES(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIuivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterIuivOES");
            return false;
        }
    }

    bool Gles::callGlScissorArrayvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto first = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glScissorArrayvNV(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
            if (glScissorArrayvNV != nullptr) {
                glScissorArrayvNV(first, count, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScissorArrayvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScissorArrayvNV");
            return false;
        }
    }

    bool Gles::callGlScissorIndexedNV(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto bottom = stack->pop<int32_t>();
        auto left = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glScissorIndexedNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", index, left, bottom, width, height);
            if (glScissorIndexedNV != nullptr) {
                glScissorIndexedNV(index, left, bottom, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScissorIndexedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScissorIndexedNV");
            return false;
        }
    }

    bool Gles::callGlScissorIndexedvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLint*>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glScissorIndexedvNV(%" PRIu32 ", %p)", index, v);
            if (glScissorIndexedvNV != nullptr) {
                glScissorIndexedvNV(index, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScissorIndexedvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScissorIndexedvNV");
            return false;
        }
    }

    bool Gles::callGlSelectPerfMonitorCountersAMD(Stack* stack, bool pushReturn) {
        auto counterList = stack->pop<GLuint*>();
        auto numCounters = stack->pop<int32_t>();
        auto group = stack->pop<uint32_t>();
        auto enable = stack->pop<uint8_t>();
        auto monitor = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSelectPerfMonitorCountersAMD(%" PRIu32 ", %" PRIu8 ", %" PRIu32 ", %" PRId32 ", %p)", monitor, enable, group, numCounters, counterList);
            if (glSelectPerfMonitorCountersAMD != nullptr) {
                glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSelectPerfMonitorCountersAMD");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSelectPerfMonitorCountersAMD");
            return false;
        }
    }

    bool Gles::callGlSetFenceNV(Stack* stack, bool pushReturn) {
        auto condition = stack->pop<GLenum>();
        auto fence = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSetFenceNV(%" PRIu32 ", %u)", fence, condition);
            if (glSetFenceNV != nullptr) {
                glSetFenceNV(fence, condition);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSetFenceNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSetFenceNV");
            return false;
        }
    }

    bool Gles::callGlStartTilingQCOM(Stack* stack, bool pushReturn) {
        auto preserveMask = stack->pop<GLbitfield>();
        auto height = stack->pop<uint32_t>();
        auto width = stack->pop<uint32_t>();
        auto y = stack->pop<uint32_t>();
        auto x = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStartTilingQCOM(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %u)", x, y, width, height, preserveMask);
            if (glStartTilingQCOM != nullptr) {
                glStartTilingQCOM(x, y, width, height, preserveMask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStartTilingQCOM");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStartTilingQCOM");
            return false;
        }
    }

    bool Gles::callGlStencilFillPathInstancedNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto mask = stack->pop<uint32_t>();
        auto fillMode = stack->pop<GLenum>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %" PRIu32 ", %u, %p)", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
            if (glStencilFillPathInstancedNV != nullptr) {
                glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilFillPathInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilFillPathInstancedNV");
            return false;
        }
    }

    bool Gles::callGlStencilFillPathNV(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        auto fillMode = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilFillPathNV(%" PRIu32 ", %u, %" PRIu32 ")", path, fillMode, mask);
            if (glStencilFillPathNV != nullptr) {
                glStencilFillPathNV(path, fillMode, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilFillPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilFillPathNV");
            return false;
        }
    }

    bool Gles::callGlStencilStrokePathInstancedNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto mask = stack->pop<uint32_t>();
        auto reference = stack->pop<int32_t>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %u, %p)", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
            if (glStencilStrokePathInstancedNV != nullptr) {
                glStencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilStrokePathInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilStrokePathInstancedNV");
            return false;
        }
    }

    bool Gles::callGlStencilStrokePathNV(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        auto reference = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilStrokePathNV(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")", path, reference, mask);
            if (glStencilStrokePathNV != nullptr) {
                glStencilStrokePathNV(path, reference, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilStrokePathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilStrokePathNV");
            return false;
        }
    }

    bool Gles::callGlStencilThenCoverFillPathInstancedNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto coverMode = stack->pop<GLenum>();
        auto mask = stack->pop<uint32_t>();
        auto fillMode = stack->pop<GLenum>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilThenCoverFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
            if (glStencilThenCoverFillPathInstancedNV != nullptr) {
                glStencilThenCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilThenCoverFillPathInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilThenCoverFillPathInstancedNV");
            return false;
        }
    }

    bool Gles::callGlStencilThenCoverFillPathNV(Stack* stack, bool pushReturn) {
        auto coverMode = stack->pop<GLenum>();
        auto mask = stack->pop<uint32_t>();
        auto fillMode = stack->pop<GLenum>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilThenCoverFillPathNV(%" PRIu32 ", %u, %" PRIu32 ", %u)", path, fillMode, mask, coverMode);
            if (glStencilThenCoverFillPathNV != nullptr) {
                glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilThenCoverFillPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilThenCoverFillPathNV");
            return false;
        }
    }

    bool Gles::callGlStencilThenCoverStrokePathInstancedNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto coverMode = stack->pop<GLenum>();
        auto mask = stack->pop<uint32_t>();
        auto reference = stack->pop<int32_t>();
        auto pathBase = stack->pop<uint32_t>();
        auto paths = stack->pop<void*>();
        auto pathNameType = stack->pop<GLenum>();
        auto numPaths = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilThenCoverStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %" PRIu32 ", %u, %u, %p)", numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
            if (glStencilThenCoverStrokePathInstancedNV != nullptr) {
                glStencilThenCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilThenCoverStrokePathInstancedNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilThenCoverStrokePathInstancedNV");
            return false;
        }
    }

    bool Gles::callGlStencilThenCoverStrokePathNV(Stack* stack, bool pushReturn) {
        auto coverMode = stack->pop<GLenum>();
        auto mask = stack->pop<uint32_t>();
        auto reference = stack->pop<int32_t>();
        auto path = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilThenCoverStrokePathNV(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %u)", path, reference, mask, coverMode);
            if (glStencilThenCoverStrokePathNV != nullptr) {
                glStencilThenCoverStrokePathNV(path, reference, mask, coverMode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilThenCoverStrokePathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilThenCoverStrokePathNV");
            return false;
        }
    }

    bool Gles::callGlSubpixelPrecisionBiasNV(Stack* stack, bool pushReturn) {
        auto ybits = stack->pop<uint32_t>();
        auto xbits = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSubpixelPrecisionBiasNV(%" PRIu32 ", %" PRIu32 ")", xbits, ybits);
            if (glSubpixelPrecisionBiasNV != nullptr) {
                glSubpixelPrecisionBiasNV(xbits, ybits);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSubpixelPrecisionBiasNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSubpixelPrecisionBiasNV");
            return false;
        }
    }

    bool Gles::callGlTestFenceNV(Stack* stack, bool pushReturn) {
        auto fence = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTestFenceNV(%" PRIu32 ")", fence);
            if (glTestFenceNV != nullptr) {
                GLboolean return_value = glTestFenceNV(fence);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTestFenceNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTestFenceNV");
            return false;
        }
    }

    bool Gles::callGlTexBufferOES(Stack* stack, bool pushReturn) {
        auto buffer = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexBufferOES(%u, %u, %" PRIu32 ")", target, internalformat, buffer);
            if (glTexBufferOES != nullptr) {
                glTexBufferOES(target, internalformat, buffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexBufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexBufferOES");
            return false;
        }
    }

    bool Gles::callGlTexBufferRangeOES(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto buffer = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexBufferRangeOES(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, internalformat, buffer, offset, size);
            if (glTexBufferRangeOES != nullptr) {
                glTexBufferRangeOES(target, internalformat, buffer, offset, size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexBufferRangeOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexBufferRangeOES");
            return false;
        }
    }

    bool Gles::callGlTexImage3DOES(Stack* stack, bool pushReturn) {
        auto pixels = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto border = stack->pop<int32_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexImage3DOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, internalformat, width, height, depth, border, format, type, pixels);
            if (glTexImage3DOES != nullptr) {
                glTexImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexImage3DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexImage3DOES");
            return false;
        }
    }

    bool Gles::callGlTexPageCommitmentEXT(Stack* stack, bool pushReturn) {
        auto commit = stack->pop<uint8_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexPageCommitmentEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
            if (glTexPageCommitmentEXT != nullptr) {
                glTexPageCommitmentEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexPageCommitmentEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexPageCommitmentEXT");
            return false;
        }
    }

    bool Gles::callGlTexParameterIivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterIivOES(%u, %u, %p)", target, pname, params);
            if (glTexParameterIivOES != nullptr) {
                glTexParameterIivOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterIivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterIivOES");
            return false;
        }
    }

    bool Gles::callGlTexParameterIuivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterIuivOES(%u, %u, %p)", target, pname, params);
            if (glTexParameterIuivOES != nullptr) {
                glTexParameterIuivOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterIuivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterIuivOES");
            return false;
        }
    }

    bool Gles::callGlTexStorage1DEXT(Stack* stack, bool pushReturn) {
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage1DEXT(%u, %" PRId32 ", %u, %" PRId32 ")", target, levels, format, width);
            if (glTexStorage1DEXT != nullptr) {
                glTexStorage1DEXT(target, levels, format, width);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage1DEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage1DEXT");
            return false;
        }
    }

    bool Gles::callGlTexStorage2DEXT(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage2DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, levels, format, width, height);
            if (glTexStorage2DEXT != nullptr) {
                glTexStorage2DEXT(target, levels, format, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage2DEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage2DEXT");
            return false;
        }
    }

    bool Gles::callGlTexStorage3DEXT(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage3DEXT(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, levels, format, width, height, depth);
            if (glTexStorage3DEXT != nullptr) {
                glTexStorage3DEXT(target, levels, format, width, height, depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage3DEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage3DEXT");
            return false;
        }
    }

    bool Gles::callGlTexSubImage3DOES(Stack* stack, bool pushReturn) {
        auto pixels = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexSubImage3DOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
            if (glTexSubImage3DOES != nullptr) {
                glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexSubImage3DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexSubImage3DOES");
            return false;
        }
    }

    bool Gles::callGlTextureStorage1DEXT(Stack* stack, bool pushReturn) {
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTextureStorage1DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ")", texture, target, levels, format, width);
            if (glTextureStorage1DEXT != nullptr) {
                glTextureStorage1DEXT(texture, target, levels, format, width);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTextureStorage1DEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTextureStorage1DEXT");
            return false;
        }
    }

    bool Gles::callGlTextureStorage2DEXT(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTextureStorage2DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", texture, target, levels, format, width, height);
            if (glTextureStorage2DEXT != nullptr) {
                glTextureStorage2DEXT(texture, target, levels, format, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTextureStorage2DEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTextureStorage2DEXT");
            return false;
        }
    }

    bool Gles::callGlTextureStorage3DEXT(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTextureStorage3DEXT(%" PRIu32 ", %u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, target, levels, format, width, height, depth);
            if (glTextureStorage3DEXT != nullptr) {
                glTextureStorage3DEXT(texture, target, levels, format, width, height, depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTextureStorage3DEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTextureStorage3DEXT");
            return false;
        }
    }

    bool Gles::callGlTextureViewEXT(Stack* stack, bool pushReturn) {
        auto numlayers = stack->pop<uint32_t>();
        auto minlayer = stack->pop<uint32_t>();
        auto numlevels = stack->pop<uint32_t>();
        auto minlevel = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto origtexture = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTextureViewEXT(%" PRIu32 ", %u, %" PRIu32 ", %u, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
            if (glTextureViewEXT != nullptr) {
                glTextureViewEXT(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTextureViewEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTextureViewEXT");
            return false;
        }
    }

    bool Gles::callGlTextureViewOES(Stack* stack, bool pushReturn) {
        auto numlayers = stack->pop<uint32_t>();
        auto minlayer = stack->pop<uint32_t>();
        auto numlevels = stack->pop<uint32_t>();
        auto minlevel = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto origtexture = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTextureViewOES(%" PRIu32 ", %u, %" PRIu32 ", %u, %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
            if (glTextureViewOES != nullptr) {
                glTextureViewOES(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTextureViewOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTextureViewOES");
            return false;
        }
    }

    bool Gles::callGlTransformPathNV(Stack* stack, bool pushReturn) {
        auto transformValues = stack->pop<GLfloat*>();
        auto transformType = stack->pop<GLenum>();
        auto srcPath = stack->pop<uint32_t>();
        auto resultPath = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTransformPathNV(%" PRIu32 ", %" PRIu32 ", %u, %p)", resultPath, srcPath, transformType, transformValues);
            if (glTransformPathNV != nullptr) {
                glTransformPathNV(resultPath, srcPath, transformType, transformValues);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTransformPathNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTransformPathNV");
            return false;
        }
    }

    bool Gles::callGlUniformHandleui64NV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<uint64_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformHandleui64NV(%" PRId32 ", %" PRIu64 ")", location, value);
            if (glUniformHandleui64NV != nullptr) {
                glUniformHandleui64NV(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformHandleui64NV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformHandleui64NV");
            return false;
        }
    }

    bool Gles::callGlUniformHandleui64vNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint64*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformHandleui64vNV(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
            if (glUniformHandleui64vNV != nullptr) {
                glUniformHandleui64vNV(location, count, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformHandleui64vNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformHandleui64vNV");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix2x3fvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix2x3fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
            if (glUniformMatrix2x3fvNV != nullptr) {
                glUniformMatrix2x3fvNV(location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x3fvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix2x3fvNV");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix2x4fvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix2x4fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
            if (glUniformMatrix2x4fvNV != nullptr) {
                glUniformMatrix2x4fvNV(location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x4fvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix2x4fvNV");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix3x2fvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix3x2fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
            if (glUniformMatrix3x2fvNV != nullptr) {
                glUniformMatrix3x2fvNV(location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x2fvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix3x2fvNV");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix3x4fvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix3x4fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
            if (glUniformMatrix3x4fvNV != nullptr) {
                glUniformMatrix3x4fvNV(location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x4fvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix3x4fvNV");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix4x2fvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix4x2fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
            if (glUniformMatrix4x2fvNV != nullptr) {
                glUniformMatrix4x2fvNV(location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x2fvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix4x2fvNV");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix4x3fvNV(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix4x3fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, value);
            if (glUniformMatrix4x3fvNV != nullptr) {
                glUniformMatrix4x3fvNV(location, count, transpose, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x3fvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix4x3fvNV");
            return false;
        }
    }

    bool Gles::callGlUnmapBufferOES(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glUnmapBufferOES(%u)", target);
            if (glUnmapBufferOES != nullptr) {
                GLboolean return_value = glUnmapBufferOES(target);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUnmapBufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUnmapBufferOES");
            return false;
        }
    }

    bool Gles::callGlUseProgramStagesEXT(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        auto stages = stack->pop<GLbitfield>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUseProgramStagesEXT(%" PRIu32 ", %u, %" PRIu32 ")", pipeline, stages, program);
            if (glUseProgramStagesEXT != nullptr) {
                glUseProgramStagesEXT(pipeline, stages, program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUseProgramStagesEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUseProgramStagesEXT");
            return false;
        }
    }

    bool Gles::callGlValidateProgramPipelineEXT(Stack* stack, bool pushReturn) {
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glValidateProgramPipelineEXT(%" PRIu32 ")", pipeline);
            if (glValidateProgramPipelineEXT != nullptr) {
                glValidateProgramPipelineEXT(pipeline);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glValidateProgramPipelineEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glValidateProgramPipelineEXT");
            return false;
        }
    }

    bool Gles::callGlVertexAttribDivisorANGLE(Stack* stack, bool pushReturn) {
        auto divisor = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribDivisorANGLE(%" PRIu32 ", %" PRIu32 ")", index, divisor);
            if (glVertexAttribDivisorANGLE != nullptr) {
                glVertexAttribDivisorANGLE(index, divisor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisorANGLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribDivisorANGLE");
            return false;
        }
    }

    bool Gles::callGlVertexAttribDivisorEXT(Stack* stack, bool pushReturn) {
        auto divisor = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribDivisorEXT(%" PRIu32 ", %" PRIu32 ")", index, divisor);
            if (glVertexAttribDivisorEXT != nullptr) {
                glVertexAttribDivisorEXT(index, divisor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisorEXT");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribDivisorEXT");
            return false;
        }
    }

    bool Gles::callGlVertexAttribDivisorNV(Stack* stack, bool pushReturn) {
        auto divisor = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribDivisorNV(%" PRIu32 ", %" PRIu32 ")", index, divisor);
            if (glVertexAttribDivisorNV != nullptr) {
                glVertexAttribDivisorNV(index, divisor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisorNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribDivisorNV");
            return false;
        }
    }

    bool Gles::callGlViewportArrayvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto first = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glViewportArrayvNV(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
            if (glViewportArrayvNV != nullptr) {
                glViewportArrayvNV(first, count, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glViewportArrayvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glViewportArrayvNV");
            return false;
        }
    }

    bool Gles::callGlViewportIndexedfNV(Stack* stack, bool pushReturn) {
        auto h = stack->pop<float>();
        auto w = stack->pop<float>();
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glViewportIndexedfNV(%" PRIu32 ", %f, %f, %f, %f)", index, x, y, w, h);
            if (glViewportIndexedfNV != nullptr) {
                glViewportIndexedfNV(index, x, y, w, h);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glViewportIndexedfNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glViewportIndexedfNV");
            return false;
        }
    }

    bool Gles::callGlViewportIndexedfvNV(Stack* stack, bool pushReturn) {
        auto v = stack->pop<GLfloat*>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glViewportIndexedfvNV(%" PRIu32 ", %p)", index, v);
            if (glViewportIndexedfvNV != nullptr) {
                glViewportIndexedfvNV(index, v);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glViewportIndexedfvNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glViewportIndexedfvNV");
            return false;
        }
    }

    bool Gles::callGlWaitSyncAPPLE(Stack* stack, bool pushReturn) {
        auto timeout = stack->pop<uint64_t>();
        auto flag = stack->pop<GLbitfield>();
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glWaitSyncAPPLE(%p, %u, %" PRIu64 ")", sync, flag, timeout);
            if (glWaitSyncAPPLE != nullptr) {
                glWaitSyncAPPLE(sync, flag, timeout);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glWaitSyncAPPLE");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glWaitSyncAPPLE");
            return false;
        }
    }

    bool Gles::callGlWeightPathsNV(Stack* stack, bool pushReturn) {
        auto weights = stack->pop<GLfloat*>();
        auto paths = stack->pop<GLuint*>();
        auto numPaths = stack->pop<int32_t>();
        auto resultPath = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glWeightPathsNV(%" PRIu32 ", %" PRId32 ", %p, %p)", resultPath, numPaths, paths, weights);
            if (glWeightPathsNV != nullptr) {
                glWeightPathsNV(resultPath, numPaths, paths, weights);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glWeightPathsNV");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glWeightPathsNV");
            return false;
        }
    }

    bool Gles::callGlBlendBarrier(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glBlendBarrier()");
            if (glBlendBarrier != nullptr) {
                glBlendBarrier();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendBarrier");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendBarrier");
            return false;
        }
    }

    bool Gles::callGlBlendColor(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<float>();
        auto blue = stack->pop<float>();
        auto green = stack->pop<float>();
        auto red = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendColor(%f, %f, %f, %f)", red, green, blue, alpha);
            if (glBlendColor != nullptr) {
                glBlendColor(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendColor");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendColor");
            return false;
        }
    }

    bool Gles::callGlBlendEquation(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquation(%u)", equation);
            if (glBlendEquation != nullptr) {
                glBlendEquation(equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquation");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquation");
            return false;
        }
    }

    bool Gles::callGlBlendEquationSeparate(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<GLenum>();
        auto rgb = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationSeparate(%u, %u)", rgb, alpha);
            if (glBlendEquationSeparate != nullptr) {
                glBlendEquationSeparate(rgb, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparate");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationSeparate");
            return false;
        }
    }

    bool Gles::callGlBlendEquationSeparatei(Stack* stack, bool pushReturn) {
        auto modeAlpha = stack->pop<GLenum>();
        auto modeRGB = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationSeparatei(%" PRIu32 ", %u, %u)", buf, modeRGB, modeAlpha);
            if (glBlendEquationSeparatei != nullptr) {
                glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparatei");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationSeparatei");
            return false;
        }
    }

    bool Gles::callGlBlendEquationi(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationi(%" PRIu32 ", %u)", buf, mode);
            if (glBlendEquationi != nullptr) {
                glBlendEquationi(buf, mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationi");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationi");
            return false;
        }
    }

    bool Gles::callGlBlendFunc(Stack* stack, bool pushReturn) {
        auto dst_factor = stack->pop<GLenum>();
        auto src_factor = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFunc(%u, %u)", src_factor, dst_factor);
            if (glBlendFunc != nullptr) {
                glBlendFunc(src_factor, dst_factor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFunc");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFunc");
            return false;
        }
    }

    bool Gles::callGlBlendFuncSeparate(Stack* stack, bool pushReturn) {
        auto dst_factor_alpha = stack->pop<GLenum>();
        auto src_factor_alpha = stack->pop<GLenum>();
        auto dst_factor_rgb = stack->pop<GLenum>();
        auto src_factor_rgb = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFuncSeparate(%u, %u, %u, %u)", src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
            if (glBlendFuncSeparate != nullptr) {
                glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparate");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFuncSeparate");
            return false;
        }
    }

    bool Gles::callGlBlendFuncSeparatei(Stack* stack, bool pushReturn) {
        auto dstAlpha = stack->pop<GLenum>();
        auto srcAlpha = stack->pop<GLenum>();
        auto dstRGB = stack->pop<GLenum>();
        auto srcRGB = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFuncSeparatei(%" PRIu32 ", %u, %u, %u, %u)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
            if (glBlendFuncSeparatei != nullptr) {
                glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparatei");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFuncSeparatei");
            return false;
        }
    }

    bool Gles::callGlBlendFunci(Stack* stack, bool pushReturn) {
        auto dst = stack->pop<GLenum>();
        auto src = stack->pop<GLenum>();
        auto buf = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFunci(%" PRIu32 ", %u, %u)", buf, src, dst);
            if (glBlendFunci != nullptr) {
                glBlendFunci(buf, src, dst);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFunci");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFunci");
            return false;
        }
    }

    bool Gles::callGlDepthFunc(Stack* stack, bool pushReturn) {
        auto function = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthFunc(%u)", function);
            if (glDepthFunc != nullptr) {
                glDepthFunc(function);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthFunc");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthFunc");
            return false;
        }
    }

    bool Gles::callGlSampleCoverage(Stack* stack, bool pushReturn) {
        auto invert = stack->pop<uint8_t>();
        auto value = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glSampleCoverage(%f, %" PRIu8 ")", value, invert);
            if (glSampleCoverage != nullptr) {
                glSampleCoverage(value, invert);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSampleCoverage");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSampleCoverage");
            return false;
        }
    }

    bool Gles::callGlSampleMaski(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<GLbitfield>();
        auto maskNumber = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSampleMaski(%" PRIu32 ", %u)", maskNumber, mask);
            if (glSampleMaski != nullptr) {
                glSampleMaski(maskNumber, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSampleMaski");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSampleMaski");
            return false;
        }
    }

    bool Gles::callGlScissor(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glScissor(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, width, height);
            if (glScissor != nullptr) {
                glScissor(x, y, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScissor");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScissor");
            return false;
        }
    }

    bool Gles::callGlStencilFunc(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        auto ref = stack->pop<int32_t>();
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilFunc(%u, %" PRId32 ", %" PRIu32 ")", func, ref, mask);
            if (glStencilFunc != nullptr) {
                glStencilFunc(func, ref, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilFunc");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilFunc");
            return false;
        }
    }

    bool Gles::callGlStencilFuncSeparate(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        auto reference_value = stack->pop<int32_t>();
        auto function = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilFuncSeparate(%u, %u, %" PRId32 ", %" PRIu32 ")", face, function, reference_value, mask);
            if (glStencilFuncSeparate != nullptr) {
                glStencilFuncSeparate(face, function, reference_value, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilFuncSeparate");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilFuncSeparate");
            return false;
        }
    }

    bool Gles::callGlStencilOp(Stack* stack, bool pushReturn) {
        auto zpass = stack->pop<GLenum>();
        auto zfail = stack->pop<GLenum>();
        auto fail = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilOp(%u, %u, %u)", fail, zfail, zpass);
            if (glStencilOp != nullptr) {
                glStencilOp(fail, zfail, zpass);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilOp");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilOp");
            return false;
        }
    }

    bool Gles::callGlStencilOpSeparate(Stack* stack, bool pushReturn) {
        auto stencil_pass_depth_pass = stack->pop<GLenum>();
        auto stencil_pass_depth_fail = stack->pop<GLenum>();
        auto stencil_fail = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilOpSeparate(%u, %u, %u, %u)", face, stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
            if (glStencilOpSeparate != nullptr) {
                glStencilOpSeparate(face, stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilOpSeparate");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilOpSeparate");
            return false;
        }
    }

    bool Gles::callGlBindFramebuffer(Stack* stack, bool pushReturn) {
        auto framebuffer = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindFramebuffer(%u, %" PRIu32 ")", target, framebuffer);
            if (glBindFramebuffer != nullptr) {
                glBindFramebuffer(target, framebuffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindFramebuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindFramebuffer");
            return false;
        }
    }

    bool Gles::callGlBindRenderbuffer(Stack* stack, bool pushReturn) {
        auto renderbuffer = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindRenderbuffer(%u, %" PRIu32 ")", target, renderbuffer);
            if (glBindRenderbuffer != nullptr) {
                glBindRenderbuffer(target, renderbuffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindRenderbuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindRenderbuffer");
            return false;
        }
    }

    bool Gles::callGlBlitFramebuffer(Stack* stack, bool pushReturn) {
        auto filter = stack->pop<GLenum>();
        auto mask = stack->pop<GLbitfield>();
        auto dstY1 = stack->pop<int32_t>();
        auto dstX1 = stack->pop<int32_t>();
        auto dstY0 = stack->pop<int32_t>();
        auto dstX0 = stack->pop<int32_t>();
        auto srcY1 = stack->pop<int32_t>();
        auto srcX1 = stack->pop<int32_t>();
        auto srcY0 = stack->pop<int32_t>();
        auto srcX0 = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBlitFramebuffer(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
            if (glBlitFramebuffer != nullptr) {
                glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlitFramebuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlitFramebuffer");
            return false;
        }
    }

    bool Gles::callGlCheckFramebufferStatus(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCheckFramebufferStatus(%u)", target);
            if (glCheckFramebufferStatus != nullptr) {
                GLenum return_value = glCheckFramebufferStatus(target);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCheckFramebufferStatus");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCheckFramebufferStatus");
            return false;
        }
    }

    bool Gles::callGlClear(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<GLbitfield>();
        if (stack->isValid()) {
            GAPID_INFO("glClear(%u)", mask);
            if (glClear != nullptr) {
                glClear(mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClear");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClear");
            return false;
        }
    }

    bool Gles::callGlClearBufferfi(Stack* stack, bool pushReturn) {
        auto stencil = stack->pop<int32_t>();
        auto depth = stack->pop<float>();
        auto drawbuffer = stack->pop<int32_t>();
        auto buffer = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClearBufferfi(%u, %" PRId32 ", %f, %" PRId32 ")", buffer, drawbuffer, depth, stencil);
            if (glClearBufferfi != nullptr) {
                glClearBufferfi(buffer, drawbuffer, depth, stencil);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearBufferfi");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearBufferfi");
            return false;
        }
    }

    bool Gles::callGlClearBufferfv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto drawbuffer = stack->pop<int32_t>();
        auto buffer = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClearBufferfv(%u, %" PRId32 ", %p)", buffer, drawbuffer, value);
            if (glClearBufferfv != nullptr) {
                glClearBufferfv(buffer, drawbuffer, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearBufferfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearBufferfv");
            return false;
        }
    }

    bool Gles::callGlClearBufferiv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto drawbuffer = stack->pop<int32_t>();
        auto buffer = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClearBufferiv(%u, %" PRId32 ", %p)", buffer, drawbuffer, value);
            if (glClearBufferiv != nullptr) {
                glClearBufferiv(buffer, drawbuffer, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearBufferiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearBufferiv");
            return false;
        }
    }

    bool Gles::callGlClearBufferuiv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLuint*>();
        auto drawbuffer = stack->pop<int32_t>();
        auto buffer = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClearBufferuiv(%u, %" PRId32 ", %p)", buffer, drawbuffer, value);
            if (glClearBufferuiv != nullptr) {
                glClearBufferuiv(buffer, drawbuffer, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearBufferuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearBufferuiv");
            return false;
        }
    }

    bool Gles::callGlClearColor(Stack* stack, bool pushReturn) {
        auto a = stack->pop<float>();
        auto b = stack->pop<float>();
        auto g = stack->pop<float>();
        auto r = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glClearColor(%f, %f, %f, %f)", r, g, b, a);
            if (glClearColor != nullptr) {
                glClearColor(r, g, b, a);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearColor");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearColor");
            return false;
        }
    }

    bool Gles::callGlClearDepthf(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glClearDepthf(%f)", depth);
            if (glClearDepthf != nullptr) {
                glClearDepthf(depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearDepthf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearDepthf");
            return false;
        }
    }

    bool Gles::callGlClearStencil(Stack* stack, bool pushReturn) {
        auto stencil = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glClearStencil(%" PRId32 ")", stencil);
            if (glClearStencil != nullptr) {
                glClearStencil(stencil);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearStencil");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearStencil");
            return false;
        }
    }

    bool Gles::callGlColorMask(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<uint8_t>();
        auto blue = stack->pop<uint8_t>();
        auto green = stack->pop<uint8_t>();
        auto red = stack->pop<uint8_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColorMask(%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", red, green, blue, alpha);
            if (glColorMask != nullptr) {
                glColorMask(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColorMask");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColorMask");
            return false;
        }
    }

    bool Gles::callGlColorMaski(Stack* stack, bool pushReturn) {
        auto a = stack->pop<uint8_t>();
        auto b = stack->pop<uint8_t>();
        auto g = stack->pop<uint8_t>();
        auto r = stack->pop<uint8_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColorMaski(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", index, r, g, b, a);
            if (glColorMaski != nullptr) {
                glColorMaski(index, r, g, b, a);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColorMaski");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColorMaski");
            return false;
        }
    }

    bool Gles::callGlDeleteFramebuffers(Stack* stack, bool pushReturn) {
        auto framebuffers = stack->pop<FramebufferId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteFramebuffers(%" PRId32 ", %p)", count, framebuffers);
            if (glDeleteFramebuffers != nullptr) {
                glDeleteFramebuffers(count, framebuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteFramebuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteFramebuffers");
            return false;
        }
    }

    bool Gles::callGlDeleteRenderbuffers(Stack* stack, bool pushReturn) {
        auto renderbuffers = stack->pop<RenderbufferId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteRenderbuffers(%" PRId32 ", %p)", count, renderbuffers);
            if (glDeleteRenderbuffers != nullptr) {
                glDeleteRenderbuffers(count, renderbuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteRenderbuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteRenderbuffers");
            return false;
        }
    }

    bool Gles::callGlDepthMask(Stack* stack, bool pushReturn) {
        auto enabled = stack->pop<uint8_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthMask(%" PRIu8 ")", enabled);
            if (glDepthMask != nullptr) {
                glDepthMask(enabled);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthMask");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthMask");
            return false;
        }
    }

    bool Gles::callGlDrawBuffers(Stack* stack, bool pushReturn) {
        auto bufs = stack->pop<GLenum*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawBuffers(%" PRId32 ", %p)", n, bufs);
            if (glDrawBuffers != nullptr) {
                glDrawBuffers(n, bufs);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawBuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawBuffers");
            return false;
        }
    }

    bool Gles::callGlFramebufferParameteri(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferParameteri(%u, %u, %" PRId32 ")", target, pname, param);
            if (glFramebufferParameteri != nullptr) {
                glFramebufferParameteri(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferParameteri");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferParameteri");
            return false;
        }
    }

    bool Gles::callGlFramebufferRenderbuffer(Stack* stack, bool pushReturn) {
        auto renderbuffer = stack->pop<uint32_t>();
        auto renderbuffer_target = stack->pop<GLenum>();
        auto framebuffer_attachment = stack->pop<GLenum>();
        auto framebuffer_target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferRenderbuffer(%u, %u, %u, %" PRIu32 ")", framebuffer_target, framebuffer_attachment, renderbuffer_target, renderbuffer);
            if (glFramebufferRenderbuffer != nullptr) {
                glFramebufferRenderbuffer(framebuffer_target, framebuffer_attachment, renderbuffer_target, renderbuffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferRenderbuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferRenderbuffer");
            return false;
        }
    }

    bool Gles::callGlFramebufferTexture(Stack* stack, bool pushReturn) {
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTexture(%u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, texture, level);
            if (glFramebufferTexture != nullptr) {
                glFramebufferTexture(target, attachment, texture, level);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTexture");
            return false;
        }
    }

    bool Gles::callGlFramebufferTexture2D(Stack* stack, bool pushReturn) {
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto texture_target = stack->pop<GLenum>();
        auto framebuffer_attachment = stack->pop<GLenum>();
        auto framebuffer_target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTexture2D(%u, %u, %u, %" PRIu32 ", %" PRId32 ")", framebuffer_target, framebuffer_attachment, texture_target, texture, level);
            if (glFramebufferTexture2D != nullptr) {
                glFramebufferTexture2D(framebuffer_target, framebuffer_attachment, texture_target, texture, level);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTexture2D");
            return false;
        }
    }

    bool Gles::callGlFramebufferTextureLayer(Stack* stack, bool pushReturn) {
        auto layer = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTextureLayer(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, layer);
            if (glFramebufferTextureLayer != nullptr) {
                glFramebufferTextureLayer(target, attachment, texture, level, layer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTextureLayer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTextureLayer");
            return false;
        }
    }

    bool Gles::callGlGenFramebuffers(Stack* stack, bool pushReturn) {
        auto framebuffers = stack->pop<FramebufferId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenFramebuffers(%" PRId32 ", %p)", count, framebuffers);
            if (glGenFramebuffers != nullptr) {
                glGenFramebuffers(count, framebuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenFramebuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenFramebuffers");
            return false;
        }
    }

    bool Gles::callGlGenRenderbuffers(Stack* stack, bool pushReturn) {
        auto renderbuffers = stack->pop<RenderbufferId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenRenderbuffers(%" PRId32 ", %p)", count, renderbuffers);
            if (glGenRenderbuffers != nullptr) {
                glGenRenderbuffers(count, renderbuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenRenderbuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenRenderbuffers");
            return false;
        }
    }

    bool Gles::callGlGetFramebufferAttachmentParameteriv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto framebuffer_target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFramebufferAttachmentParameteriv(%u, %u, %u, %p)", framebuffer_target, attachment, parameter, value);
            if (glGetFramebufferAttachmentParameteriv != nullptr) {
                glGetFramebufferAttachmentParameteriv(framebuffer_target, attachment, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFramebufferAttachmentParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFramebufferAttachmentParameteriv");
            return false;
        }
    }

    bool Gles::callGlGetFramebufferParameteriv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFramebufferParameteriv(%u, %u, %p)", target, pname, params);
            if (glGetFramebufferParameteriv != nullptr) {
                glGetFramebufferParameteriv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFramebufferParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFramebufferParameteriv");
            return false;
        }
    }

    bool Gles::callGlGetRenderbufferParameteriv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetRenderbufferParameteriv(%u, %u, %p)", target, parameter, values);
            if (glGetRenderbufferParameteriv != nullptr) {
                glGetRenderbufferParameteriv(target, parameter, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetRenderbufferParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetRenderbufferParameteriv");
            return false;
        }
    }

    bool Gles::callGlInvalidateFramebuffer(Stack* stack, bool pushReturn) {
        auto attachments = stack->pop<GLenum*>();
        auto count = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glInvalidateFramebuffer(%u, %" PRId32 ", %p)", target, count, attachments);
            if (glInvalidateFramebuffer != nullptr) {
                glInvalidateFramebuffer(target, count, attachments);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glInvalidateFramebuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glInvalidateFramebuffer");
            return false;
        }
    }

    bool Gles::callGlInvalidateSubFramebuffer(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto attachments = stack->pop<GLenum*>();
        auto numAttachments = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glInvalidateSubFramebuffer(%u, %" PRId32 ", %p, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, numAttachments, attachments, x, y, width, height);
            if (glInvalidateSubFramebuffer != nullptr) {
                glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glInvalidateSubFramebuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glInvalidateSubFramebuffer");
            return false;
        }
    }

    bool Gles::callGlIsFramebuffer(Stack* stack, bool pushReturn) {
        auto framebuffer = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsFramebuffer(%" PRIu32 ")", framebuffer);
            if (glIsFramebuffer != nullptr) {
                GLboolean return_value = glIsFramebuffer(framebuffer);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsFramebuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsFramebuffer");
            return false;
        }
    }

    bool Gles::callGlIsRenderbuffer(Stack* stack, bool pushReturn) {
        auto renderbuffer = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsRenderbuffer(%" PRIu32 ")", renderbuffer);
            if (glIsRenderbuffer != nullptr) {
                GLboolean return_value = glIsRenderbuffer(renderbuffer);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsRenderbuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsRenderbuffer");
            return false;
        }
    }

    bool Gles::callGlReadBuffer(Stack* stack, bool pushReturn) {
        auto src = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glReadBuffer(%u)", src);
            if (glReadBuffer != nullptr) {
                glReadBuffer(src);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadBuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadBuffer");
            return false;
        }
    }

    bool Gles::callGlReadPixels(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glReadPixels(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", x, y, width, height, format, type, data);
            if (glReadPixels != nullptr) {
                glReadPixels(x, y, width, height, format, type, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadPixels");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadPixels");
            return false;
        }
    }

    bool Gles::callGlReadnPixels(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto bufSize = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glReadnPixels(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %" PRId32 ", %p)", x, y, width, height, format, type, bufSize, data);
            if (glReadnPixels != nullptr) {
                glReadnPixels(x, y, width, height, format, type, bufSize, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReadnPixels");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReadnPixels");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorage(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorage(%u, %u, %" PRId32 ", %" PRId32 ")", target, internalformat, width, height);
            if (glRenderbufferStorage != nullptr) {
                glRenderbufferStorage(target, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorage");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorage");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageMultisample(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, samples, internalformat, width, height);
            if (glRenderbufferStorageMultisample != nullptr) {
                glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageMultisample");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageMultisample");
            return false;
        }
    }

    bool Gles::callGlStencilMask(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilMask(%" PRIu32 ")", mask);
            if (glStencilMask != nullptr) {
                glStencilMask(mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilMask");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilMask");
            return false;
        }
    }

    bool Gles::callGlStencilMaskSeparate(Stack* stack, bool pushReturn) {
        auto mask = stack->pop<uint32_t>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glStencilMaskSeparate(%u, %" PRIu32 ")", face, mask);
            if (glStencilMaskSeparate != nullptr) {
                glStencilMaskSeparate(face, mask);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glStencilMaskSeparate");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glStencilMaskSeparate");
            return false;
        }
    }

    bool Gles::callGlDisable(Stack* stack, bool pushReturn) {
        auto capability = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDisable(%u)", capability);
            if (glDisable != nullptr) {
                glDisable(capability);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisable");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisable");
            return false;
        }
    }

    bool Gles::callGlDisablei(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto capability = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDisablei(%u, %" PRIu32 ")", capability, index);
            if (glDisablei != nullptr) {
                glDisablei(capability, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisablei");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisablei");
            return false;
        }
    }

    bool Gles::callGlEnable(Stack* stack, bool pushReturn) {
        auto capability = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEnable(%u)", capability);
            if (glEnable != nullptr) {
                glEnable(capability);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnable");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnable");
            return false;
        }
    }

    bool Gles::callGlEnablei(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto capability = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEnablei(%u, %" PRIu32 ")", capability, index);
            if (glEnablei != nullptr) {
                glEnablei(capability, index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnablei");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnablei");
            return false;
        }
    }

    bool Gles::callGlFinish(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glFinish()");
            if (glFinish != nullptr) {
                glFinish();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFinish");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFinish");
            return false;
        }
    }

    bool Gles::callGlFlush(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glFlush()");
            if (glFlush != nullptr) {
                glFlush();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFlush");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFlush");
            return false;
        }
    }

    bool Gles::callGlFlushMappedBufferRange(Stack* stack, bool pushReturn) {
        auto length = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFlushMappedBufferRange(%u, %" PRId32 ", %" PRId32 ")", target, offset, length);
            if (glFlushMappedBufferRange != nullptr) {
                glFlushMappedBufferRange(target, offset, length);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFlushMappedBufferRange");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFlushMappedBufferRange");
            return false;
        }
    }

    bool Gles::callGlGetError(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glGetError()");
            if (glGetError != nullptr) {
                GLenum return_value = glGetError();
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetError");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetError");
            return false;
        }
    }

    bool Gles::callGlGetGraphicsResetStatus(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glGetGraphicsResetStatus()");
            if (glGetGraphicsResetStatus != nullptr) {
                GLenum return_value = glGetGraphicsResetStatus();
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetGraphicsResetStatus");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetGraphicsResetStatus");
            return false;
        }
    }

    bool Gles::callGlHint(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glHint(%u, %u)", target, mode);
            if (glHint != nullptr) {
                glHint(target, mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glHint");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glHint");
            return false;
        }
    }

    bool Gles::callGlActiveShaderProgram(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glActiveShaderProgram(%" PRIu32 ", %" PRIu32 ")", pipeline, program);
            if (glActiveShaderProgram != nullptr) {
                glActiveShaderProgram(pipeline, program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glActiveShaderProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glActiveShaderProgram");
            return false;
        }
    }

    bool Gles::callGlAttachShader(Stack* stack, bool pushReturn) {
        auto shader = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glAttachShader(%" PRIu32 ", %" PRIu32 ")", program, shader);
            if (glAttachShader != nullptr) {
                glAttachShader(program, shader);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glAttachShader");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glAttachShader");
            return false;
        }
    }

    bool Gles::callGlBindAttribLocation(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto location = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindAttribLocation(%" PRIu32 ", %" PRIu32 ", %s)", program, location, name);
            if (glBindAttribLocation != nullptr) {
                glBindAttribLocation(program, location, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindAttribLocation");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindAttribLocation");
            return false;
        }
    }

    bool Gles::callGlBindProgramPipeline(Stack* stack, bool pushReturn) {
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindProgramPipeline(%" PRIu32 ")", pipeline);
            if (glBindProgramPipeline != nullptr) {
                glBindProgramPipeline(pipeline);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindProgramPipeline");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindProgramPipeline");
            return false;
        }
    }

    bool Gles::callGlCompileShader(Stack* stack, bool pushReturn) {
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCompileShader(%" PRIu32 ")", shader);
            if (glCompileShader != nullptr) {
                glCompileShader(shader);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompileShader");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompileShader");
            return false;
        }
    }

    bool Gles::callGlCreateProgram(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glCreateProgram()");
            if (glCreateProgram != nullptr) {
                ProgramId return_value = glCreateProgram();
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<ProgramId>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCreateProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCreateProgram");
            return false;
        }
    }

    bool Gles::callGlCreateShader(Stack* stack, bool pushReturn) {
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCreateShader(%u)", type);
            if (glCreateShader != nullptr) {
                ShaderId return_value = glCreateShader(type);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<ShaderId>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCreateShader");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCreateShader");
            return false;
        }
    }

    bool Gles::callGlCreateShaderProgramv(Stack* stack, bool pushReturn) {
        auto strings = stack->pop<GLchar**>();
        auto count = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCreateShaderProgramv(%u, %" PRId32 ", %p)", type, count, strings);
            if (glCreateShaderProgramv != nullptr) {
                ProgramId return_value = glCreateShaderProgramv(type, count, strings);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<ProgramId>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCreateShaderProgramv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCreateShaderProgramv");
            return false;
        }
    }

    bool Gles::callGlDeleteProgram(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteProgram(%" PRIu32 ")", program);
            if (glDeleteProgram != nullptr) {
                glDeleteProgram(program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteProgram");
            return false;
        }
    }

    bool Gles::callGlDeleteProgramPipelines(Stack* stack, bool pushReturn) {
        auto pipelines = stack->pop<PipelineId*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteProgramPipelines(%" PRId32 ", %p)", n, pipelines);
            if (glDeleteProgramPipelines != nullptr) {
                glDeleteProgramPipelines(n, pipelines);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteProgramPipelines");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteProgramPipelines");
            return false;
        }
    }

    bool Gles::callGlDeleteShader(Stack* stack, bool pushReturn) {
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteShader(%" PRIu32 ")", shader);
            if (glDeleteShader != nullptr) {
                glDeleteShader(shader);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteShader");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteShader");
            return false;
        }
    }

    bool Gles::callGlDetachShader(Stack* stack, bool pushReturn) {
        auto shader = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDetachShader(%" PRIu32 ", %" PRIu32 ")", program, shader);
            if (glDetachShader != nullptr) {
                glDetachShader(program, shader);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDetachShader");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDetachShader");
            return false;
        }
    }

    bool Gles::callGlDispatchCompute(Stack* stack, bool pushReturn) {
        auto num_groups_z = stack->pop<uint32_t>();
        auto num_groups_y = stack->pop<uint32_t>();
        auto num_groups_x = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDispatchCompute(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", num_groups_x, num_groups_y, num_groups_z);
            if (glDispatchCompute != nullptr) {
                glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDispatchCompute");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDispatchCompute");
            return false;
        }
    }

    bool Gles::callGlDispatchComputeIndirect(Stack* stack, bool pushReturn) {
        auto indirect = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDispatchComputeIndirect(%" PRId32 ")", indirect);
            if (glDispatchComputeIndirect != nullptr) {
                glDispatchComputeIndirect(indirect);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDispatchComputeIndirect");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDispatchComputeIndirect");
            return false;
        }
    }

    bool Gles::callGlGenProgramPipelines(Stack* stack, bool pushReturn) {
        auto pipelines = stack->pop<PipelineId*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenProgramPipelines(%" PRId32 ", %p)", n, pipelines);
            if (glGenProgramPipelines != nullptr) {
                glGenProgramPipelines(n, pipelines);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenProgramPipelines");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenProgramPipelines");
            return false;
        }
    }

    bool Gles::callGlGetActiveAttrib(Stack* stack, bool pushReturn) {
        auto name = stack->pop<GLchar*>();
        auto type = stack->pop<GLenum*>();
        auto vector_count = stack->pop<GLint*>();
        auto buffer_bytes_written = stack->pop<GLsizei*>();
        auto buffer_size = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetActiveAttrib(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)", program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
            if (glGetActiveAttrib != nullptr) {
                glGetActiveAttrib(program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetActiveAttrib");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetActiveAttrib");
            return false;
        }
    }

    bool Gles::callGlGetActiveUniform(Stack* stack, bool pushReturn) {
        auto name = stack->pop<GLchar*>();
        auto type = stack->pop<GLenum*>();
        auto vector_count = stack->pop<GLint*>();
        auto buffer_bytes_written = stack->pop<GLsizei*>();
        auto buffer_size = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetActiveUniform(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)", program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
            if (glGetActiveUniform != nullptr) {
                glGetActiveUniform(program, index, buffer_size, buffer_bytes_written, vector_count, type, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetActiveUniform");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetActiveUniform");
            return false;
        }
    }

    bool Gles::callGlGetActiveUniformBlockName(Stack* stack, bool pushReturn) {
        auto name = stack->pop<GLchar*>();
        auto buffer_bytes_written = stack->pop<GLsizei*>();
        auto buffer_size = stack->pop<int32_t>();
        auto uniform_block_index = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetActiveUniformBlockName(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)", program, uniform_block_index, buffer_size, buffer_bytes_written, name);
            if (glGetActiveUniformBlockName != nullptr) {
                glGetActiveUniformBlockName(program, uniform_block_index, buffer_size, buffer_bytes_written, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformBlockName");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetActiveUniformBlockName");
            return false;
        }
    }

    bool Gles::callGlGetActiveUniformBlockiv(Stack* stack, bool pushReturn) {
        auto parameters = stack->pop<GLint*>();
        auto parameter_name = stack->pop<GLenum>();
        auto uniform_block_index = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetActiveUniformBlockiv(%" PRIu32 ", %" PRIu32 ", %u, %p)", program, uniform_block_index, parameter_name, parameters);
            if (glGetActiveUniformBlockiv != nullptr) {
                glGetActiveUniformBlockiv(program, uniform_block_index, parameter_name, parameters);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformBlockiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetActiveUniformBlockiv");
            return false;
        }
    }

    bool Gles::callGlGetActiveUniformsiv(Stack* stack, bool pushReturn) {
        auto parameters = stack->pop<GLint*>();
        auto parameter_name = stack->pop<GLenum>();
        auto uniform_indices = stack->pop<UniformIndex*>();
        auto uniform_count = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetActiveUniformsiv(%" PRIu32 ", %" PRId32 ", %p, %u, %p)", program, uniform_count, uniform_indices, parameter_name, parameters);
            if (glGetActiveUniformsiv != nullptr) {
                glGetActiveUniformsiv(program, uniform_count, uniform_indices, parameter_name, parameters);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformsiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetActiveUniformsiv");
            return false;
        }
    }

    bool Gles::callGlGetAttachedShaders(Stack* stack, bool pushReturn) {
        auto shaders = stack->pop<ShaderId*>();
        auto shaders_length_written = stack->pop<GLsizei*>();
        auto buffer_length = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetAttachedShaders(%" PRIu32 ", %" PRId32 ", %p, %p)", program, buffer_length, shaders_length_written, shaders);
            if (glGetAttachedShaders != nullptr) {
                glGetAttachedShaders(program, buffer_length, shaders_length_written, shaders);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetAttachedShaders");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetAttachedShaders");
            return false;
        }
    }

    bool Gles::callGlGetAttribLocation(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetAttribLocation(%" PRIu32 ", %s)", program, name);
            if (glGetAttribLocation != nullptr) {
                GLint return_value = glGetAttribLocation(program, name);
                GAPID_INFO("Returned: %" PRId32 "", return_value);
                if (pushReturn) {
                    stack->push<GLint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetAttribLocation");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetAttribLocation");
            return false;
        }
    }

    bool Gles::callGlGetFragDataLocation(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFragDataLocation(%" PRIu32 ", %s)", program, name);
            if (glGetFragDataLocation != nullptr) {
                GLint return_value = glGetFragDataLocation(program, name);
                GAPID_INFO("Returned: %" PRId32 "", return_value);
                if (pushReturn) {
                    stack->push<GLint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFragDataLocation");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFragDataLocation");
            return false;
        }
    }

    bool Gles::callGlGetProgramBinary(Stack* stack, bool pushReturn) {
        auto binary = stack->pop<void*>();
        auto binaryFormat = stack->pop<GLenum*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramBinary(%" PRIu32 ", %" PRId32 ", %p, %p, %p)", program, bufSize, length, binaryFormat, binary);
            if (glGetProgramBinary != nullptr) {
                glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramBinary");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramBinary");
            return false;
        }
    }

    bool Gles::callGlGetProgramInfoLog(Stack* stack, bool pushReturn) {
        auto info = stack->pop<GLchar*>();
        auto string_length_written = stack->pop<GLsizei*>();
        auto buffer_length = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)", program, buffer_length, string_length_written, info);
            if (glGetProgramInfoLog != nullptr) {
                glGetProgramInfoLog(program, buffer_length, string_length_written, info);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramInfoLog");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramInfoLog");
            return false;
        }
    }

    bool Gles::callGlGetProgramInterfaceiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramInterfaceiv(%" PRIu32 ", %u, %u, %p)", program, programInterface, pname, params);
            if (glGetProgramInterfaceiv != nullptr) {
                glGetProgramInterfaceiv(program, programInterface, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramInterfaceiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramInterfaceiv");
            return false;
        }
    }

    bool Gles::callGlGetProgramPipelineInfoLog(Stack* stack, bool pushReturn) {
        auto infoLog = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramPipelineInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)", pipeline, bufSize, length, infoLog);
            if (glGetProgramPipelineInfoLog != nullptr) {
                glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineInfoLog");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramPipelineInfoLog");
            return false;
        }
    }

    bool Gles::callGlGetProgramPipelineiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramPipelineiv(%" PRIu32 ", %u, %p)", pipeline, pname, params);
            if (glGetProgramPipelineiv != nullptr) {
                glGetProgramPipelineiv(pipeline, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramPipelineiv");
            return false;
        }
    }

    bool Gles::callGlGetProgramResourceIndex(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramResourceIndex(%" PRIu32 ", %u, %s)", program, programInterface, name);
            if (glGetProgramResourceIndex != nullptr) {
                GLuint return_value = glGetProgramResourceIndex(program, programInterface, name);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<GLuint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceIndex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramResourceIndex");
            return false;
        }
    }

    bool Gles::callGlGetProgramResourceLocation(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramResourceLocation(%" PRIu32 ", %u, %s)", program, programInterface, name);
            if (glGetProgramResourceLocation != nullptr) {
                GLint return_value = glGetProgramResourceLocation(program, programInterface, name);
                GAPID_INFO("Returned: %" PRId32 "", return_value);
                if (pushReturn) {
                    stack->push<GLint>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceLocation");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramResourceLocation");
            return false;
        }
    }

    bool Gles::callGlGetProgramResourceName(Stack* stack, bool pushReturn) {
        auto name = stack->pop<GLchar*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramResourceName(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %p)", program, programInterface, index, bufSize, length, name);
            if (glGetProgramResourceName != nullptr) {
                glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceName");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramResourceName");
            return false;
        }
    }

    bool Gles::callGlGetProgramResourceiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto props = stack->pop<GLenum*>();
        auto propCount = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        auto programInterface = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramResourceiv(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %p, %p)", program, programInterface, index, propCount, props, bufSize, length, params);
            if (glGetProgramResourceiv != nullptr) {
                glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramResourceiv");
            return false;
        }
    }

    bool Gles::callGlGetProgramiv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetProgramiv(%" PRIu32 ", %u, %p)", program, parameter, value);
            if (glGetProgramiv != nullptr) {
                glGetProgramiv(program, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetProgramiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetProgramiv");
            return false;
        }
    }

    bool Gles::callGlGetShaderInfoLog(Stack* stack, bool pushReturn) {
        auto info = stack->pop<GLchar*>();
        auto string_length_written = stack->pop<GLsizei*>();
        auto buffer_length = stack->pop<int32_t>();
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetShaderInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, buffer_length, string_length_written, info);
            if (glGetShaderInfoLog != nullptr) {
                glGetShaderInfoLog(shader, buffer_length, string_length_written, info);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetShaderInfoLog");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetShaderInfoLog");
            return false;
        }
    }

    bool Gles::callGlGetShaderPrecisionFormat(Stack* stack, bool pushReturn) {
        auto precision = stack->pop<GLint*>();
        auto range = stack->pop<GLint*>();
        auto precision_type = stack->pop<GLenum>();
        auto shader_type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetShaderPrecisionFormat(%u, %u, %p, %p)", shader_type, precision_type, range, precision);
            if (glGetShaderPrecisionFormat != nullptr) {
                glGetShaderPrecisionFormat(shader_type, precision_type, range, precision);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetShaderPrecisionFormat");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetShaderPrecisionFormat");
            return false;
        }
    }

    bool Gles::callGlGetShaderSource(Stack* stack, bool pushReturn) {
        auto source = stack->pop<GLchar*>();
        auto string_length_written = stack->pop<GLsizei*>();
        auto buffer_length = stack->pop<int32_t>();
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, buffer_length, string_length_written, source);
            if (glGetShaderSource != nullptr) {
                glGetShaderSource(shader, buffer_length, string_length_written, source);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetShaderSource");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetShaderSource");
            return false;
        }
    }

    bool Gles::callGlGetShaderiv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetShaderiv(%" PRIu32 ", %u, %p)", shader, parameter, value);
            if (glGetShaderiv != nullptr) {
                glGetShaderiv(shader, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetShaderiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetShaderiv");
            return false;
        }
    }

    bool Gles::callGlGetUniformBlockIndex(Stack* stack, bool pushReturn) {
        auto uniformBlockName = stack->pop<const char*>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetUniformBlockIndex(%" PRIu32 ", %s)", program, uniformBlockName);
            if (glGetUniformBlockIndex != nullptr) {
                UniformBlockId return_value = glGetUniformBlockIndex(program, uniformBlockName);
                GAPID_INFO("Returned: %" PRIu32 "", return_value);
                if (pushReturn) {
                    stack->push<UniformBlockId>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetUniformBlockIndex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetUniformBlockIndex");
            return false;
        }
    }

    bool Gles::callGlGetUniformIndices(Stack* stack, bool pushReturn) {
        auto uniformIndices = stack->pop<UniformIndex*>();
        auto uniformNames = stack->pop<GLchar**>();
        auto uniformCount = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetUniformIndices(%" PRIu32 ", %" PRId32 ", %p, %p)", program, uniformCount, uniformNames, uniformIndices);
            if (glGetUniformIndices != nullptr) {
                glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetUniformIndices");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetUniformIndices");
            return false;
        }
    }

    bool Gles::callGlGetUniformLocation(Stack* stack, bool pushReturn) {
        auto name = stack->pop<const char*>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetUniformLocation(%" PRIu32 ", %s)", program, name);
            if (glGetUniformLocation != nullptr) {
                UniformLocation return_value = glGetUniformLocation(program, name);
                GAPID_INFO("Returned: %" PRId32 "", return_value);
                if (pushReturn) {
                    stack->push<UniformLocation>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetUniformLocation");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetUniformLocation");
            return false;
        }
    }

    bool Gles::callGlGetUniformfv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetUniformfv(%" PRIu32 ", %" PRId32 ", %p)", program, location, values);
            if (glGetUniformfv != nullptr) {
                glGetUniformfv(program, location, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetUniformfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetUniformfv");
            return false;
        }
    }

    bool Gles::callGlGetUniformiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetUniformiv(%" PRIu32 ", %" PRId32 ", %p)", program, location, values);
            if (glGetUniformiv != nullptr) {
                glGetUniformiv(program, location, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetUniformiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetUniformiv");
            return false;
        }
    }

    bool Gles::callGlGetUniformuiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetUniformuiv(%" PRIu32 ", %" PRId32 ", %p)", program, location, values);
            if (glGetUniformuiv != nullptr) {
                glGetUniformuiv(program, location, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetUniformuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetUniformuiv");
            return false;
        }
    }

    bool Gles::callGlGetnUniformfv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformfv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, values);
            if (glGetnUniformfv != nullptr) {
                glGetnUniformfv(program, location, bufSize, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformfv");
            return false;
        }
    }

    bool Gles::callGlGetnUniformiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, values);
            if (glGetnUniformiv != nullptr) {
                glGetnUniformiv(program, location, bufSize, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformiv");
            return false;
        }
    }

    bool Gles::callGlGetnUniformuiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto bufSize = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetnUniformuiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, bufSize, values);
            if (glGetnUniformuiv != nullptr) {
                glGetnUniformuiv(program, location, bufSize, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetnUniformuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetnUniformuiv");
            return false;
        }
    }

    bool Gles::callGlIsProgram(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsProgram(%" PRIu32 ")", program);
            if (glIsProgram != nullptr) {
                GLboolean return_value = glIsProgram(program);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsProgram");
            return false;
        }
    }

    bool Gles::callGlIsProgramPipeline(Stack* stack, bool pushReturn) {
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsProgramPipeline(%" PRIu32 ")", pipeline);
            if (glIsProgramPipeline != nullptr) {
                GLboolean return_value = glIsProgramPipeline(pipeline);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsProgramPipeline");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsProgramPipeline");
            return false;
        }
    }

    bool Gles::callGlIsShader(Stack* stack, bool pushReturn) {
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsShader(%" PRIu32 ")", shader);
            if (glIsShader != nullptr) {
                GLboolean return_value = glIsShader(shader);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsShader");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsShader");
            return false;
        }
    }

    bool Gles::callGlLinkProgram(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glLinkProgram(%" PRIu32 ")", program);
            if (glLinkProgram != nullptr) {
                glLinkProgram(program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLinkProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLinkProgram");
            return false;
        }
    }

    bool Gles::callGlMemoryBarrier(Stack* stack, bool pushReturn) {
        auto barriers = stack->pop<GLbitfield>();
        if (stack->isValid()) {
            GAPID_INFO("glMemoryBarrier(%u)", barriers);
            if (glMemoryBarrier != nullptr) {
                glMemoryBarrier(barriers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMemoryBarrier");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMemoryBarrier");
            return false;
        }
    }

    bool Gles::callGlMemoryBarrierByRegion(Stack* stack, bool pushReturn) {
        auto barriers = stack->pop<GLbitfield>();
        if (stack->isValid()) {
            GAPID_INFO("glMemoryBarrierByRegion(%u)", barriers);
            if (glMemoryBarrierByRegion != nullptr) {
                glMemoryBarrierByRegion(barriers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMemoryBarrierByRegion");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMemoryBarrierByRegion");
            return false;
        }
    }

    bool Gles::callGlProgramBinary(Stack* stack, bool pushReturn) {
        auto length = stack->pop<int32_t>();
        auto binary = stack->pop<void*>();
        auto binaryFormat = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramBinary(%" PRIu32 ", %u, %p, %" PRId32 ")", program, binaryFormat, binary, length);
            if (glProgramBinary != nullptr) {
                glProgramBinary(program, binaryFormat, binary, length);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramBinary");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramBinary");
            return false;
        }
    }

    bool Gles::callGlProgramParameteri(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramParameteri(%" PRIu32 ", %u, %" PRId32 ")", program, pname, value);
            if (glProgramParameteri != nullptr) {
                glProgramParameteri(program, pname, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramParameteri");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramParameteri");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1f(Stack* stack, bool pushReturn) {
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1f(%" PRIu32 ", %" PRId32 ", %f)", program, location, value0);
            if (glProgramUniform1f != nullptr) {
                glProgramUniform1f(program, location, value0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1f");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform1fv != nullptr) {
                glProgramUniform1fv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1i(Stack* stack, bool pushReturn) {
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1i(%" PRIu32 ", %" PRId32 ", %" PRId32 ")", program, location, value0);
            if (glProgramUniform1i != nullptr) {
                glProgramUniform1i(program, location, value0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1i");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform1iv != nullptr) {
                glProgramUniform1iv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1iv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1ui(Stack* stack, bool pushReturn) {
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")", program, location, value0);
            if (glProgramUniform1ui != nullptr) {
                glProgramUniform1ui(program, location, value0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1ui");
            return false;
        }
    }

    bool Gles::callGlProgramUniform1uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform1uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform1uiv != nullptr) {
                glProgramUniform1uiv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform1uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform1uiv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2f(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2f(%" PRIu32 ", %" PRId32 ", %f, %f)", program, location, value0, value1);
            if (glProgramUniform2f != nullptr) {
                glProgramUniform2f(program, location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2f");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform2fv != nullptr) {
                glProgramUniform2fv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2i(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<int32_t>();
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, value0, value1);
            if (glProgramUniform2i != nullptr) {
                glProgramUniform2i(program, location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2i");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform2iv != nullptr) {
                glProgramUniform2iv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2iv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2ui(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<uint32_t>();
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ")", program, location, value0, value1);
            if (glProgramUniform2ui != nullptr) {
                glProgramUniform2ui(program, location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2ui");
            return false;
        }
    }

    bool Gles::callGlProgramUniform2uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform2uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform2uiv != nullptr) {
                glProgramUniform2uiv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform2uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform2uiv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3f(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<float>();
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3f(%" PRIu32 ", %" PRId32 ", %f, %f, %f)", program, location, value0, value1, value2);
            if (glProgramUniform3f != nullptr) {
                glProgramUniform3f(program, location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3f");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform3fv != nullptr) {
                glProgramUniform3fv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3i(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<int32_t>();
        auto value1 = stack->pop<int32_t>();
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, value0, value1, value2);
            if (glProgramUniform3i != nullptr) {
                glProgramUniform3i(program, location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3i");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform3iv != nullptr) {
                glProgramUniform3iv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3iv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3ui(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<uint32_t>();
        auto value1 = stack->pop<uint32_t>();
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, value0, value1, value2);
            if (glProgramUniform3ui != nullptr) {
                glProgramUniform3ui(program, location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3ui");
            return false;
        }
    }

    bool Gles::callGlProgramUniform3uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform3uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform3uiv != nullptr) {
                glProgramUniform3uiv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform3uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform3uiv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4f(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<float>();
        auto value2 = stack->pop<float>();
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4f(%" PRIu32 ", %" PRId32 ", %f, %f, %f, %f)", program, location, value0, value1, value2, value3);
            if (glProgramUniform4f != nullptr) {
                glProgramUniform4f(program, location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4f");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform4fv != nullptr) {
                glProgramUniform4fv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4i(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<int32_t>();
        auto value2 = stack->pop<int32_t>();
        auto value1 = stack->pop<int32_t>();
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", program, location, value0, value1, value2, value3);
            if (glProgramUniform4i != nullptr) {
                glProgramUniform4i(program, location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4i");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform4iv != nullptr) {
                glProgramUniform4iv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4iv");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4ui(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<uint32_t>();
        auto value2 = stack->pop<uint32_t>();
        auto value1 = stack->pop<uint32_t>();
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, location, value0, value1, value2, value3);
            if (glProgramUniform4ui != nullptr) {
                glProgramUniform4ui(program, location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4ui");
            return false;
        }
    }

    bool Gles::callGlProgramUniform4uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniform4uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
            if (glProgramUniform4uiv != nullptr) {
                glProgramUniform4uiv(program, location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniform4uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniform4uiv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix2fv != nullptr) {
                glProgramUniformMatrix2fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix2fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix2x3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix2x3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix2x3fv != nullptr) {
                glProgramUniformMatrix2x3fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2x3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix2x3fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix2x4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix2x4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix2x4fv != nullptr) {
                glProgramUniformMatrix2x4fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2x4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix2x4fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix3fv != nullptr) {
                glProgramUniformMatrix3fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix3fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix3x2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix3x2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix3x2fv != nullptr) {
                glProgramUniformMatrix3x2fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3x2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix3x2fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix3x4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix3x4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix3x4fv != nullptr) {
                glProgramUniformMatrix3x4fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3x4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix3x4fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix4fv != nullptr) {
                glProgramUniformMatrix4fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix4fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix4x2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix4x2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix4x2fv != nullptr) {
                glProgramUniformMatrix4x2fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4x2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix4x2fv");
            return false;
        }
    }

    bool Gles::callGlProgramUniformMatrix4x3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glProgramUniformMatrix4x3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", program, location, count, transpose, values);
            if (glProgramUniformMatrix4x3fv != nullptr) {
                glProgramUniformMatrix4x3fv(program, location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4x3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glProgramUniformMatrix4x3fv");
            return false;
        }
    }

    bool Gles::callGlReleaseShaderCompiler(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glReleaseShaderCompiler()");
            if (glReleaseShaderCompiler != nullptr) {
                glReleaseShaderCompiler();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glReleaseShaderCompiler");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glReleaseShaderCompiler");
            return false;
        }
    }

    bool Gles::callGlShaderBinary(Stack* stack, bool pushReturn) {
        auto binary_size = stack->pop<int32_t>();
        auto binary = stack->pop<void*>();
        auto binary_format = stack->pop<GLenum>();
        auto shaders = stack->pop<ShaderId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glShaderBinary(%" PRId32 ", %p, %u, %p, %" PRId32 ")", count, shaders, binary_format, binary, binary_size);
            if (glShaderBinary != nullptr) {
                glShaderBinary(count, shaders, binary_format, binary, binary_size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glShaderBinary");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glShaderBinary");
            return false;
        }
    }

    bool Gles::callGlShaderSource(Stack* stack, bool pushReturn) {
        auto length = stack->pop<GLint*>();
        auto source = stack->pop<GLchar**>();
        auto count = stack->pop<int32_t>();
        auto shader = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)", shader, count, source, length);
            if (glShaderSource != nullptr) {
                glShaderSource(shader, count, source, length);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glShaderSource");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glShaderSource");
            return false;
        }
    }

    bool Gles::callGlUniform1f(Stack* stack, bool pushReturn) {
        auto value = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform1f(%" PRId32 ", %f)", location, value);
            if (glUniform1f != nullptr) {
                glUniform1f(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform1f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform1f");
            return false;
        }
    }

    bool Gles::callGlUniform1fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform1fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform1fv != nullptr) {
                glUniform1fv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform1fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform1fv");
            return false;
        }
    }

    bool Gles::callGlUniform1i(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform1i(%" PRId32 ", %" PRId32 ")", location, value);
            if (glUniform1i != nullptr) {
                glUniform1i(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform1i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform1i");
            return false;
        }
    }

    bool Gles::callGlUniform1iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform1iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform1iv != nullptr) {
                glUniform1iv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform1iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform1iv");
            return false;
        }
    }

    bool Gles::callGlUniform1ui(Stack* stack, bool pushReturn) {
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform1ui(%" PRId32 ", %" PRIu32 ")", location, value0);
            if (glUniform1ui != nullptr) {
                glUniform1ui(location, value0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform1ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform1ui");
            return false;
        }
    }

    bool Gles::callGlUniform1uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform1uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform1uiv != nullptr) {
                glUniform1uiv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform1uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform1uiv");
            return false;
        }
    }

    bool Gles::callGlUniform2f(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform2f(%" PRId32 ", %f, %f)", location, value0, value1);
            if (glUniform2f != nullptr) {
                glUniform2f(location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform2f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform2f");
            return false;
        }
    }

    bool Gles::callGlUniform2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform2fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform2fv != nullptr) {
                glUniform2fv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform2fv");
            return false;
        }
    }

    bool Gles::callGlUniform2i(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<int32_t>();
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform2i(%" PRId32 ", %" PRId32 ", %" PRId32 ")", location, value0, value1);
            if (glUniform2i != nullptr) {
                glUniform2i(location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform2i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform2i");
            return false;
        }
    }

    bool Gles::callGlUniform2iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform2iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform2iv != nullptr) {
                glUniform2iv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform2iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform2iv");
            return false;
        }
    }

    bool Gles::callGlUniform2ui(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<uint32_t>();
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform2ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ")", location, value0, value1);
            if (glUniform2ui != nullptr) {
                glUniform2ui(location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform2ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform2ui");
            return false;
        }
    }

    bool Gles::callGlUniform2uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform2uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform2uiv != nullptr) {
                glUniform2uiv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform2uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform2uiv");
            return false;
        }
    }

    bool Gles::callGlUniform3f(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<float>();
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform3f(%" PRId32 ", %f, %f, %f)", location, value0, value1, value2);
            if (glUniform3f != nullptr) {
                glUniform3f(location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform3f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform3f");
            return false;
        }
    }

    bool Gles::callGlUniform3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform3fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform3fv != nullptr) {
                glUniform3fv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform3fv");
            return false;
        }
    }

    bool Gles::callGlUniform3i(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<int32_t>();
        auto value1 = stack->pop<int32_t>();
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform3i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", location, value0, value1, value2);
            if (glUniform3i != nullptr) {
                glUniform3i(location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform3i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform3i");
            return false;
        }
    }

    bool Gles::callGlUniform3iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform3iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform3iv != nullptr) {
                glUniform3iv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform3iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform3iv");
            return false;
        }
    }

    bool Gles::callGlUniform3ui(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<uint32_t>();
        auto value1 = stack->pop<uint32_t>();
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform3ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", location, value0, value1, value2);
            if (glUniform3ui != nullptr) {
                glUniform3ui(location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform3ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform3ui");
            return false;
        }
    }

    bool Gles::callGlUniform3uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform3uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform3uiv != nullptr) {
                glUniform3uiv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform3uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform3uiv");
            return false;
        }
    }

    bool Gles::callGlUniform4f(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<float>();
        auto value2 = stack->pop<float>();
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform4f(%" PRId32 ", %f, %f, %f, %f)", location, value0, value1, value2, value3);
            if (glUniform4f != nullptr) {
                glUniform4f(location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform4f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform4f");
            return false;
        }
    }

    bool Gles::callGlUniform4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform4fv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform4fv != nullptr) {
                glUniform4fv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform4fv");
            return false;
        }
    }

    bool Gles::callGlUniform4i(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<int32_t>();
        auto value2 = stack->pop<int32_t>();
        auto value1 = stack->pop<int32_t>();
        auto value0 = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform4i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", location, value0, value1, value2, value3);
            if (glUniform4i != nullptr) {
                glUniform4i(location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform4i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform4i");
            return false;
        }
    }

    bool Gles::callGlUniform4iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform4iv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform4iv != nullptr) {
                glUniform4iv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform4iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform4iv");
            return false;
        }
    }

    bool Gles::callGlUniform4ui(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<uint32_t>();
        auto value2 = stack->pop<uint32_t>();
        auto value1 = stack->pop<uint32_t>();
        auto value0 = stack->pop<uint32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform4ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", location, value0, value1, value2, value3);
            if (glUniform4ui != nullptr) {
                glUniform4ui(location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform4ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform4ui");
            return false;
        }
    }

    bool Gles::callGlUniform4uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniform4uiv(%" PRId32 ", %" PRId32 ", %p)", location, count, values);
            if (glUniform4uiv != nullptr) {
                glUniform4uiv(location, count, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniform4uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniform4uiv");
            return false;
        }
    }

    bool Gles::callGlUniformBlockBinding(Stack* stack, bool pushReturn) {
        auto uniform_block_binding = stack->pop<uint32_t>();
        auto uniform_block_index = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformBlockBinding(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", program, uniform_block_index, uniform_block_binding);
            if (glUniformBlockBinding != nullptr) {
                glUniformBlockBinding(program, uniform_block_index, uniform_block_binding);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformBlockBinding");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformBlockBinding");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix2fv != nullptr) {
                glUniformMatrix2fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix2fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix2x3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix2x3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix2x3fv != nullptr) {
                glUniformMatrix2x3fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix2x3fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix2x4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix2x4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix2x4fv != nullptr) {
                glUniformMatrix2x4fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix2x4fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix3fv != nullptr) {
                glUniformMatrix3fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix3fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix3x2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix3x2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix3x2fv != nullptr) {
                glUniformMatrix3x2fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix3x2fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix3x4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix3x4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix3x4fv != nullptr) {
                glUniformMatrix3x4fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix3x4fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix4fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix4fv != nullptr) {
                glUniformMatrix4fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix4fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix4x2fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix4x2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix4x2fv != nullptr) {
                glUniformMatrix4x2fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix4x2fv");
            return false;
        }
    }

    bool Gles::callGlUniformMatrix4x3fv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto transpose = stack->pop<uint8_t>();
        auto count = stack->pop<int32_t>();
        auto location = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUniformMatrix4x3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)", location, count, transpose, values);
            if (glUniformMatrix4x3fv != nullptr) {
                glUniformMatrix4x3fv(location, count, transpose, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUniformMatrix4x3fv");
            return false;
        }
    }

    bool Gles::callGlUseProgram(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUseProgram(%" PRIu32 ")", program);
            if (glUseProgram != nullptr) {
                glUseProgram(program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUseProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUseProgram");
            return false;
        }
    }

    bool Gles::callGlUseProgramStages(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        auto stages = stack->pop<GLbitfield>();
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glUseProgramStages(%" PRIu32 ", %u, %" PRIu32 ")", pipeline, stages, program);
            if (glUseProgramStages != nullptr) {
                glUseProgramStages(pipeline, stages, program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glUseProgramStages");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glUseProgramStages");
            return false;
        }
    }

    bool Gles::callGlValidateProgram(Stack* stack, bool pushReturn) {
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glValidateProgram(%" PRIu32 ")", program);
            if (glValidateProgram != nullptr) {
                glValidateProgram(program);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glValidateProgram");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glValidateProgram");
            return false;
        }
    }

    bool Gles::callGlValidateProgramPipeline(Stack* stack, bool pushReturn) {
        auto pipeline = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glValidateProgramPipeline(%" PRIu32 ")", pipeline);
            if (glValidateProgramPipeline != nullptr) {
                glValidateProgramPipeline(pipeline);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glValidateProgramPipeline");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glValidateProgramPipeline");
            return false;
        }
    }

    bool Gles::callGlCullFace(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCullFace(%u)", mode);
            if (glCullFace != nullptr) {
                glCullFace(mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCullFace");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCullFace");
            return false;
        }
    }

    bool Gles::callGlDepthRangef(Stack* stack, bool pushReturn) {
        auto far = stack->pop<float>();
        auto near = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthRangef(%f, %f)", near, far);
            if (glDepthRangef != nullptr) {
                glDepthRangef(near, far);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthRangef");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthRangef");
            return false;
        }
    }

    bool Gles::callGlFrontFace(Stack* stack, bool pushReturn) {
        auto orientation = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFrontFace(%u)", orientation);
            if (glFrontFace != nullptr) {
                glFrontFace(orientation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFrontFace");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFrontFace");
            return false;
        }
    }

    bool Gles::callGlGetMultisamplefv(Stack* stack, bool pushReturn) {
        auto val = stack->pop<GLfloat*>();
        auto index = stack->pop<uint32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetMultisamplefv(%u, %" PRIu32 ", %p)", pname, index, val);
            if (glGetMultisamplefv != nullptr) {
                glGetMultisamplefv(pname, index, val);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetMultisamplefv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetMultisamplefv");
            return false;
        }
    }

    bool Gles::callGlLineWidth(Stack* stack, bool pushReturn) {
        auto width = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glLineWidth(%f)", width);
            if (glLineWidth != nullptr) {
                glLineWidth(width);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLineWidth");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLineWidth");
            return false;
        }
    }

    bool Gles::callGlMinSampleShading(Stack* stack, bool pushReturn) {
        auto value = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glMinSampleShading(%f)", value);
            if (glMinSampleShading != nullptr) {
                glMinSampleShading(value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMinSampleShading");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMinSampleShading");
            return false;
        }
    }

    bool Gles::callGlPolygonOffset(Stack* stack, bool pushReturn) {
        auto units = stack->pop<float>();
        auto scale_factor = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glPolygonOffset(%f, %f)", scale_factor, units);
            if (glPolygonOffset != nullptr) {
                glPolygonOffset(scale_factor, units);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPolygonOffset");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPolygonOffset");
            return false;
        }
    }

    bool Gles::callGlViewport(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glViewport(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, width, height);
            if (glViewport != nullptr) {
                glViewport(x, y, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glViewport");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glViewport");
            return false;
        }
    }

    bool Gles::callGlGetBooleaniV(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLboolean*>();
        auto index = stack->pop<uint32_t>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetBooleani_v(%u, %" PRIu32 ", %p)", param, index, values);
            if (glGetBooleani_v != nullptr) {
                glGetBooleani_v(param, index, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetBooleani_v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetBooleani_v");
            return false;
        }
    }

    bool Gles::callGlGetBooleanv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLboolean*>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetBooleanv(%u, %p)", param, values);
            if (glGetBooleanv != nullptr) {
                glGetBooleanv(param, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetBooleanv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetBooleanv");
            return false;
        }
    }

    bool Gles::callGlGetFloatv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFloatv(%u, %p)", param, values);
            if (glGetFloatv != nullptr) {
                glGetFloatv(param, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFloatv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFloatv");
            return false;
        }
    }

    bool Gles::callGlGetInteger64iV(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint64*>();
        auto index = stack->pop<uint32_t>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetInteger64i_v(%u, %" PRIu32 ", %p)", param, index, values);
            if (glGetInteger64i_v != nullptr) {
                glGetInteger64i_v(param, index, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetInteger64i_v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetInteger64i_v");
            return false;
        }
    }

    bool Gles::callGlGetInteger64v(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint64*>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetInteger64v(%u, %p)", param, values);
            if (glGetInteger64v != nullptr) {
                glGetInteger64v(param, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetInteger64v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetInteger64v");
            return false;
        }
    }

    bool Gles::callGlGetIntegeriV(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto index = stack->pop<uint32_t>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetIntegeri_v(%u, %" PRIu32 ", %p)", param, index, values);
            if (glGetIntegeri_v != nullptr) {
                glGetIntegeri_v(param, index, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetIntegeri_v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetIntegeri_v");
            return false;
        }
    }

    bool Gles::callGlGetIntegerv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetIntegerv(%u, %p)", param, values);
            if (glGetIntegerv != nullptr) {
                glGetIntegerv(param, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetIntegerv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetIntegerv");
            return false;
        }
    }

    bool Gles::callGlGetInternalformativ(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto bufSize = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetInternalformativ(%u, %u, %u, %" PRId32 ", %p)", target, internalformat, pname, bufSize, params);
            if (glGetInternalformativ != nullptr) {
                glGetInternalformativ(target, internalformat, pname, bufSize, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetInternalformativ");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetInternalformativ");
            return false;
        }
    }

    bool Gles::callGlGetString(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetString(%u)", param);
            if (glGetString != nullptr) {
                GLubyte* return_value = glGetString(param);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<GLubyte*>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetString");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetString");
            return false;
        }
    }

    bool Gles::callGlGetStringi(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto name = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetStringi(%u, %" PRIu32 ")", name, index);
            if (glGetStringi != nullptr) {
                GLubyte* return_value = glGetStringi(name, index);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<GLubyte*>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetStringi");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetStringi");
            return false;
        }
    }

    bool Gles::callGlIsEnabled(Stack* stack, bool pushReturn) {
        auto capability = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glIsEnabled(%u)", capability);
            if (glIsEnabled != nullptr) {
                GLboolean return_value = glIsEnabled(capability);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsEnabled");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsEnabled");
            return false;
        }
    }

    bool Gles::callGlIsEnabledi(Stack* stack, bool pushReturn) {
        auto index = stack->pop<uint32_t>();
        auto capability = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glIsEnabledi(%u, %" PRIu32 ")", capability, index);
            if (glIsEnabledi != nullptr) {
                GLboolean return_value = glIsEnabledi(capability, index);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsEnabledi");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsEnabledi");
            return false;
        }
    }

    bool Gles::callGlClientWaitSync(Stack* stack, bool pushReturn) {
        auto timeout = stack->pop<uint64_t>();
        auto syncFlags = stack->pop<GLbitfield>();
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glClientWaitSync(%p, %u, %" PRIu64 ")", sync, syncFlags, timeout);
            if (glClientWaitSync != nullptr) {
                GLenum return_value = glClientWaitSync(sync, syncFlags, timeout);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClientWaitSync");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClientWaitSync");
            return false;
        }
    }

    bool Gles::callGlDeleteSync(Stack* stack, bool pushReturn) {
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteSync(%p)", sync);
            if (glDeleteSync != nullptr) {
                glDeleteSync(sync);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteSync");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteSync");
            return false;
        }
    }

    bool Gles::callGlFenceSync(Stack* stack, bool pushReturn) {
        auto syncFlags = stack->pop<GLbitfield>();
        auto condition = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFenceSync(%u, %u)", condition, syncFlags);
            if (glFenceSync != nullptr) {
                GLsync return_value = glFenceSync(condition, syncFlags);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<GLsync>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFenceSync");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFenceSync");
            return false;
        }
    }

    bool Gles::callGlGetSynciv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSynciv(%p, %u, %" PRId32 ", %p, %p)", sync, pname, bufSize, length, values);
            if (glGetSynciv != nullptr) {
                glGetSynciv(sync, pname, bufSize, length, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSynciv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSynciv");
            return false;
        }
    }

    bool Gles::callGlIsSync(Stack* stack, bool pushReturn) {
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glIsSync(%p)", sync);
            if (glIsSync != nullptr) {
                GLboolean return_value = glIsSync(sync);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsSync");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsSync");
            return false;
        }
    }

    bool Gles::callGlWaitSync(Stack* stack, bool pushReturn) {
        auto timeout = stack->pop<uint64_t>();
        auto syncFlags = stack->pop<GLbitfield>();
        auto sync = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glWaitSync(%p, %u, %" PRIu64 ")", sync, syncFlags, timeout);
            if (glWaitSync != nullptr) {
                glWaitSync(sync, syncFlags, timeout);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glWaitSync");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glWaitSync");
            return false;
        }
    }

    bool Gles::callGlActiveTexture(Stack* stack, bool pushReturn) {
        auto unit = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glActiveTexture(%u)", unit);
            if (glActiveTexture != nullptr) {
                glActiveTexture(unit);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glActiveTexture");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glActiveTexture");
            return false;
        }
    }

    bool Gles::callGlBindImageTexture(Stack* stack, bool pushReturn) {
        auto format = stack->pop<GLenum>();
        auto access = stack->pop<GLenum>();
        auto layer = stack->pop<int32_t>();
        auto layered = stack->pop<uint8_t>();
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto unit = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindImageTexture(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRIu8 ", %" PRId32 ", %u, %u)", unit, texture, level, layered, layer, access, format);
            if (glBindImageTexture != nullptr) {
                glBindImageTexture(unit, texture, level, layered, layer, access, format);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindImageTexture");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindImageTexture");
            return false;
        }
    }

    bool Gles::callGlBindSampler(Stack* stack, bool pushReturn) {
        auto sampler = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindSampler(%" PRIu32 ", %" PRIu32 ")", index, sampler);
            if (glBindSampler != nullptr) {
                glBindSampler(index, sampler);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindSampler");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindSampler");
            return false;
        }
    }

    bool Gles::callGlBindTexture(Stack* stack, bool pushReturn) {
        auto texture = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindTexture(%u, %" PRIu32 ")", target, texture);
            if (glBindTexture != nullptr) {
                glBindTexture(target, texture);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindTexture");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindTexture");
            return false;
        }
    }

    bool Gles::callGlCompressedTexImage2D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto image_size = stack->pop<int32_t>();
        auto border = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCompressedTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)", target, level, format, width, height, border, image_size, data);
            if (glCompressedTexImage2D != nullptr) {
                glCompressedTexImage2D(target, level, format, width, height, border, image_size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompressedTexImage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompressedTexImage2D");
            return false;
        }
    }

    bool Gles::callGlCompressedTexImage3D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto image_size = stack->pop<int32_t>();
        auto border = stack->pop<int32_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCompressedTexImage3D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)", target, level, internalformat, width, height, depth, border, image_size, data);
            if (glCompressedTexImage3D != nullptr) {
                glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, image_size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompressedTexImage3D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompressedTexImage3D");
            return false;
        }
    }

    bool Gles::callGlCompressedTexSubImage2D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto image_size = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCompressedTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %" PRId32 ", %p)", target, level, xoffset, yoffset, width, height, format, image_size, data);
            if (glCompressedTexSubImage2D != nullptr) {
                glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, image_size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompressedTexSubImage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompressedTexSubImage2D");
            return false;
        }
    }

    bool Gles::callGlCompressedTexSubImage3D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto image_size = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("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 (glCompressedTexSubImage3D != nullptr) {
                glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, image_size, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCompressedTexSubImage3D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCompressedTexSubImage3D");
            return false;
        }
    }

    bool Gles::callGlCopyImageSubData(Stack* stack, bool pushReturn) {
        auto srcDepth = stack->pop<int32_t>();
        auto srcHeight = stack->pop<int32_t>();
        auto srcWidth = stack->pop<int32_t>();
        auto dstZ = stack->pop<int32_t>();
        auto dstY = stack->pop<int32_t>();
        auto dstX = stack->pop<int32_t>();
        auto dstLevel = stack->pop<int32_t>();
        auto dstTarget = stack->pop<GLenum>();
        auto dstName = stack->pop<uint32_t>();
        auto srcZ = stack->pop<int32_t>();
        auto srcY = stack->pop<int32_t>();
        auto srcX = stack->pop<int32_t>();
        auto srcLevel = stack->pop<int32_t>();
        auto srcTarget = stack->pop<GLenum>();
        auto srcName = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("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 (glCopyImageSubData != nullptr) {
                glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyImageSubData");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyImageSubData");
            return false;
        }
    }

    bool Gles::callGlCopyTexImage2D(Stack* stack, bool pushReturn) {
        auto border = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto format = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyTexImage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, format, x, y, width, height, border);
            if (glCopyTexImage2D != nullptr) {
                glCopyTexImage2D(target, level, format, x, y, width, height, border);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyTexImage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyTexImage2D");
            return false;
        }
    }

    bool Gles::callGlCopyTexSubImage2D(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, xoffset, yoffset, x, y, width, height);
            if (glCopyTexSubImage2D != nullptr) {
                glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyTexSubImage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyTexSubImage2D");
            return false;
        }
    }

    bool Gles::callGlCopyTexSubImage3D(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCopyTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, level, xoffset, yoffset, zoffset, x, y, width, height);
            if (glCopyTexSubImage3D != nullptr) {
                glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCopyTexSubImage3D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCopyTexSubImage3D");
            return false;
        }
    }

    bool Gles::callGlDeleteSamplers(Stack* stack, bool pushReturn) {
        auto samplers = stack->pop<SamplerId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteSamplers(%" PRId32 ", %p)", count, samplers);
            if (glDeleteSamplers != nullptr) {
                glDeleteSamplers(count, samplers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteSamplers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteSamplers");
            return false;
        }
    }

    bool Gles::callGlDeleteTextures(Stack* stack, bool pushReturn) {
        auto textures = stack->pop<TextureId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteTextures(%" PRId32 ", %p)", count, textures);
            if (glDeleteTextures != nullptr) {
                glDeleteTextures(count, textures);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteTextures");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteTextures");
            return false;
        }
    }

    bool Gles::callGlGenSamplers(Stack* stack, bool pushReturn) {
        auto samplers = stack->pop<SamplerId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenSamplers(%" PRId32 ", %p)", count, samplers);
            if (glGenSamplers != nullptr) {
                glGenSamplers(count, samplers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenSamplers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenSamplers");
            return false;
        }
    }

    bool Gles::callGlGenTextures(Stack* stack, bool pushReturn) {
        auto textures = stack->pop<TextureId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenTextures(%" PRId32 ", %p)", count, textures);
            if (glGenTextures != nullptr) {
                glGenTextures(count, textures);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenTextures");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenTextures");
            return false;
        }
    }

    bool Gles::callGlGenerateMipmap(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGenerateMipmap(%u)", target);
            if (glGenerateMipmap != nullptr) {
                glGenerateMipmap(target);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenerateMipmap");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenerateMipmap");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterIiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterIiv(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterIiv != nullptr) {
                glGetSamplerParameterIiv(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterIiv");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterIuiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterIuiv(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterIuiv != nullptr) {
                glGetSamplerParameterIuiv(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterIuiv");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameterfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameterfv(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameterfv != nullptr) {
                glGetSamplerParameterfv(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameterfv");
            return false;
        }
    }

    bool Gles::callGlGetSamplerParameteriv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetSamplerParameteriv(%" PRIu32 ", %u, %p)", sampler, pname, params);
            if (glGetSamplerParameteriv != nullptr) {
                glGetSamplerParameteriv(sampler, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetSamplerParameteriv");
            return false;
        }
    }

    bool Gles::callGlGetTexLevelParameterfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexLevelParameterfv(%u, %" PRId32 ", %u, %p)", target, level, pname, params);
            if (glGetTexLevelParameterfv != nullptr) {
                glGetTexLevelParameterfv(target, level, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexLevelParameterfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexLevelParameterfv");
            return false;
        }
    }

    bool Gles::callGlGetTexLevelParameteriv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexLevelParameteriv(%u, %" PRId32 ", %u, %p)", target, level, pname, params);
            if (glGetTexLevelParameteriv != nullptr) {
                glGetTexLevelParameteriv(target, level, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexLevelParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexLevelParameteriv");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterIiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterIiv(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterIiv != nullptr) {
                glGetTexParameterIiv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterIiv");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterIuiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterIuiv(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterIuiv != nullptr) {
                glGetTexParameterIuiv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterIuiv");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterfv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLfloat*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterfv(%u, %u, %p)", target, parameter, values);
            if (glGetTexParameterfv != nullptr) {
                glGetTexParameterfv(target, parameter, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterfv");
            return false;
        }
    }

    bool Gles::callGlGetTexParameteriv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameteriv(%u, %u, %p)", target, parameter, values);
            if (glGetTexParameteriv != nullptr) {
                glGetTexParameteriv(target, parameter, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameteriv");
            return false;
        }
    }

    bool Gles::callGlIsSampler(Stack* stack, bool pushReturn) {
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsSampler(%" PRIu32 ")", sampler);
            if (glIsSampler != nullptr) {
                GLboolean return_value = glIsSampler(sampler);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsSampler");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsSampler");
            return false;
        }
    }

    bool Gles::callGlIsTexture(Stack* stack, bool pushReturn) {
        auto texture = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsTexture(%" PRIu32 ")", texture);
            if (glIsTexture != nullptr) {
                GLboolean return_value = glIsTexture(texture);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsTexture");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsTexture");
            return false;
        }
    }

    bool Gles::callGlPixelStorei(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto parameter = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPixelStorei(%u, %" PRId32 ")", parameter, value);
            if (glPixelStorei != nullptr) {
                glPixelStorei(parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPixelStorei");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPixelStorei");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterIiv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterIiv(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterIiv != nullptr) {
                glSamplerParameterIiv(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterIiv");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterIuiv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterIuiv(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterIuiv != nullptr) {
                glSamplerParameterIuiv(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterIuiv");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterf(%" PRIu32 ", %u, %f)", sampler, pname, param);
            if (glSamplerParameterf != nullptr) {
                glSamplerParameterf(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterf");
            return false;
        }
    }

    bool Gles::callGlSamplerParameterfv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameterfv(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameterfv != nullptr) {
                glSamplerParameterfv(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameterfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameterfv");
            return false;
        }
    }

    bool Gles::callGlSamplerParameteri(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameteri(%" PRIu32 ", %u, %" PRId32 ")", sampler, pname, param);
            if (glSamplerParameteri != nullptr) {
                glSamplerParameteri(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameteri");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameteri");
            return false;
        }
    }

    bool Gles::callGlSamplerParameteriv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto sampler = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSamplerParameteriv(%" PRIu32 ", %u, %p)", sampler, pname, param);
            if (glSamplerParameteriv != nullptr) {
                glSamplerParameteriv(sampler, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSamplerParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSamplerParameteriv");
            return false;
        }
    }

    bool Gles::callGlTexBuffer(Stack* stack, bool pushReturn) {
        auto buffer = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexBuffer(%u, %u, %" PRIu32 ")", target, internalformat, buffer);
            if (glTexBuffer != nullptr) {
                glTexBuffer(target, internalformat, buffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexBuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexBuffer");
            return false;
        }
    }

    bool Gles::callGlTexBufferRange(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto buffer = stack->pop<uint32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexBufferRange(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ")", target, internalformat, buffer, offset, size);
            if (glTexBufferRange != nullptr) {
                glTexBufferRange(target, internalformat, buffer, offset, size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexBufferRange");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexBufferRange");
            return false;
        }
    }

    bool Gles::callGlTexImage2D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto border = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internal_format = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, internal_format, width, height, border, format, type, data);
            if (glTexImage2D != nullptr) {
                glTexImage2D(target, level, internal_format, width, height, border, format, type, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexImage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexImage2D");
            return false;
        }
    }

    bool Gles::callGlTexImage3D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto border = stack->pop<int32_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, internalformat, width, height, depth, border, format, type, data);
            if (glTexImage3D != nullptr) {
                glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexImage3D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexImage3D");
            return false;
        }
    }

    bool Gles::callGlTexParameterIiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterIiv(%u, %u, %p)", target, pname, params);
            if (glTexParameterIiv != nullptr) {
                glTexParameterIiv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterIiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterIiv");
            return false;
        }
    }

    bool Gles::callGlTexParameterIuiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterIuiv(%u, %u, %p)", target, pname, params);
            if (glTexParameterIuiv != nullptr) {
                glTexParameterIuiv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterIuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterIuiv");
            return false;
        }
    }

    bool Gles::callGlTexParameterf(Stack* stack, bool pushReturn) {
        auto value = stack->pop<float>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterf(%u, %u, %f)", target, parameter, value);
            if (glTexParameterf != nullptr) {
                glTexParameterf(target, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterf");
            return false;
        }
    }

    bool Gles::callGlTexParameterfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterfv(%u, %u, %p)", target, pname, params);
            if (glTexParameterfv != nullptr) {
                glTexParameterfv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterfv");
            return false;
        }
    }

    bool Gles::callGlTexParameteri(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int32_t>();
        auto parameter = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameteri(%u, %u, %" PRId32 ")", target, parameter, value);
            if (glTexParameteri != nullptr) {
                glTexParameteri(target, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameteri");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameteri");
            return false;
        }
    }

    bool Gles::callGlTexParameteriv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameteriv(%u, %u, %p)", target, pname, params);
            if (glTexParameteriv != nullptr) {
                glTexParameteriv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameteriv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameteriv");
            return false;
        }
    }

    bool Gles::callGlTexStorage2D(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage2D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ")", target, levels, internalformat, width, height);
            if (glTexStorage2D != nullptr) {
                glTexStorage2D(target, levels, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage2D");
            return false;
        }
    }

    bool Gles::callGlTexStorage2DMultisample(Stack* stack, bool pushReturn) {
        auto fixedsamplelocations = stack->pop<uint8_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage2DMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, samples, internalformat, width, height, fixedsamplelocations);
            if (glTexStorage2DMultisample != nullptr) {
                glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage2DMultisample");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage2DMultisample");
            return false;
        }
    }

    bool Gles::callGlTexStorage3D(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto levels = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage3D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, levels, internalformat, width, height, depth);
            if (glTexStorage3D != nullptr) {
                glTexStorage3D(target, levels, internalformat, width, height, depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage3D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage3D");
            return false;
        }
    }

    bool Gles::callGlTexStorage3DMultisample(Stack* stack, bool pushReturn) {
        auto fixedsamplelocations = stack->pop<uint8_t>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto samples = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexStorage3DMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")", target, samples, internalformat, width, height, depth, fixedsamplelocations);
            if (glTexStorage3DMultisample != nullptr) {
                glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexStorage3DMultisample");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexStorage3DMultisample");
            return false;
        }
    }

    bool Gles::callGlTexSubImage2D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexSubImage2D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, width, height, format, type, data);
            if (glTexSubImage2D != nullptr) {
                glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexSubImage2D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexSubImage2D");
            return false;
        }
    }

    bool Gles::callGlTexSubImage3D(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto type = stack->pop<GLenum>();
        auto format = stack->pop<GLenum>();
        auto depth = stack->pop<int32_t>();
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto zoffset = stack->pop<int32_t>();
        auto yoffset = stack->pop<int32_t>();
        auto xoffset = stack->pop<int32_t>();
        auto level = stack->pop<int32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
            if (glTexSubImage3D != nullptr) {
                glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexSubImage3D");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexSubImage3D");
            return false;
        }
    }

    bool Gles::callGlBeginTransformFeedback(Stack* stack, bool pushReturn) {
        auto primitiveMode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBeginTransformFeedback(%u)", primitiveMode);
            if (glBeginTransformFeedback != nullptr) {
                glBeginTransformFeedback(primitiveMode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBeginTransformFeedback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBeginTransformFeedback");
            return false;
        }
    }

    bool Gles::callGlBindTransformFeedback(Stack* stack, bool pushReturn) {
        auto id = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindTransformFeedback(%u, %" PRIu32 ")", target, id);
            if (glBindTransformFeedback != nullptr) {
                glBindTransformFeedback(target, id);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindTransformFeedback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindTransformFeedback");
            return false;
        }
    }

    bool Gles::callGlDeleteTransformFeedbacks(Stack* stack, bool pushReturn) {
        auto ids = stack->pop<TransformFeedbackId*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteTransformFeedbacks(%" PRId32 ", %p)", n, ids);
            if (glDeleteTransformFeedbacks != nullptr) {
                glDeleteTransformFeedbacks(n, ids);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteTransformFeedbacks");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteTransformFeedbacks");
            return false;
        }
    }

    bool Gles::callGlEndTransformFeedback(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glEndTransformFeedback()");
            if (glEndTransformFeedback != nullptr) {
                glEndTransformFeedback();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEndTransformFeedback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEndTransformFeedback");
            return false;
        }
    }

    bool Gles::callGlGenTransformFeedbacks(Stack* stack, bool pushReturn) {
        auto ids = stack->pop<TransformFeedbackId*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenTransformFeedbacks(%" PRId32 ", %p)", n, ids);
            if (glGenTransformFeedbacks != nullptr) {
                glGenTransformFeedbacks(n, ids);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenTransformFeedbacks");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenTransformFeedbacks");
            return false;
        }
    }

    bool Gles::callGlGetTransformFeedbackVarying(Stack* stack, bool pushReturn) {
        auto name = stack->pop<GLchar*>();
        auto type = stack->pop<GLenum*>();
        auto size = stack->pop<GLsizei*>();
        auto length = stack->pop<GLsizei*>();
        auto bufSize = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTransformFeedbackVarying(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)", program, index, bufSize, length, size, type, name);
            if (glGetTransformFeedbackVarying != nullptr) {
                glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTransformFeedbackVarying");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTransformFeedbackVarying");
            return false;
        }
    }

    bool Gles::callGlIsTransformFeedback(Stack* stack, bool pushReturn) {
        auto id = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsTransformFeedback(%" PRIu32 ")", id);
            if (glIsTransformFeedback != nullptr) {
                GLboolean return_value = glIsTransformFeedback(id);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsTransformFeedback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsTransformFeedback");
            return false;
        }
    }

    bool Gles::callGlPauseTransformFeedback(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glPauseTransformFeedback()");
            if (glPauseTransformFeedback != nullptr) {
                glPauseTransformFeedback();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPauseTransformFeedback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPauseTransformFeedback");
            return false;
        }
    }

    bool Gles::callGlResumeTransformFeedback(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glResumeTransformFeedback()");
            if (glResumeTransformFeedback != nullptr) {
                glResumeTransformFeedback();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glResumeTransformFeedback");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glResumeTransformFeedback");
            return false;
        }
    }

    bool Gles::callGlTransformFeedbackVaryings(Stack* stack, bool pushReturn) {
        auto bufferMode = stack->pop<GLenum>();
        auto varyings = stack->pop<GLchar**>();
        auto count = stack->pop<int32_t>();
        auto program = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTransformFeedbackVaryings(%" PRIu32 ", %" PRId32 ", %p, %u)", program, count, varyings, bufferMode);
            if (glTransformFeedbackVaryings != nullptr) {
                glTransformFeedbackVaryings(program, count, varyings, bufferMode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTransformFeedbackVaryings");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTransformFeedbackVaryings");
            return false;
        }
    }

    bool Gles::callGlBindVertexArray(Stack* stack, bool pushReturn) {
        auto array = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindVertexArray(%" PRIu32 ")", array);
            if (glBindVertexArray != nullptr) {
                glBindVertexArray(array);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindVertexArray");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindVertexArray");
            return false;
        }
    }

    bool Gles::callGlBindVertexBuffer(Stack* stack, bool pushReturn) {
        auto stride = stack->pop<int32_t>();
        auto offset = stack->pop<int32_t>();
        auto buffer = stack->pop<uint32_t>();
        auto binding_index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glBindVertexBuffer(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")", binding_index, buffer, offset, stride);
            if (glBindVertexBuffer != nullptr) {
                glBindVertexBuffer(binding_index, buffer, offset, stride);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindVertexBuffer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindVertexBuffer");
            return false;
        }
    }

    bool Gles::callGlDeleteVertexArrays(Stack* stack, bool pushReturn) {
        auto arrays = stack->pop<VertexArrayId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteVertexArrays(%" PRId32 ", %p)", count, arrays);
            if (glDeleteVertexArrays != nullptr) {
                glDeleteVertexArrays(count, arrays);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteVertexArrays");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteVertexArrays");
            return false;
        }
    }

    bool Gles::callGlDisableVertexAttribArray(Stack* stack, bool pushReturn) {
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDisableVertexAttribArray(%" PRIu32 ")", location);
            if (glDisableVertexAttribArray != nullptr) {
                glDisableVertexAttribArray(location);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisableVertexAttribArray");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisableVertexAttribArray");
            return false;
        }
    }

    bool Gles::callGlEnableVertexAttribArray(Stack* stack, bool pushReturn) {
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glEnableVertexAttribArray(%" PRIu32 ")", location);
            if (glEnableVertexAttribArray != nullptr) {
                glEnableVertexAttribArray(location);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnableVertexAttribArray");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnableVertexAttribArray");
            return false;
        }
    }

    bool Gles::callGlGenVertexArrays(Stack* stack, bool pushReturn) {
        auto arrays = stack->pop<VertexArrayId*>();
        auto count = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenVertexArrays(%" PRId32 ", %p)", count, arrays);
            if (glGenVertexArrays != nullptr) {
                glGenVertexArrays(count, arrays);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenVertexArrays");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenVertexArrays");
            return false;
        }
    }

    bool Gles::callGlGetVertexAttribIiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetVertexAttribIiv(%" PRIu32 ", %u, %p)", index, pname, params);
            if (glGetVertexAttribIiv != nullptr) {
                glGetVertexAttribIiv(index, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribIiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetVertexAttribIiv");
            return false;
        }
    }

    bool Gles::callGlGetVertexAttribIuiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLuint*>();
        auto pname = stack->pop<GLenum>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetVertexAttribIuiv(%" PRIu32 ", %u, %p)", index, pname, params);
            if (glGetVertexAttribIuiv != nullptr) {
                glGetVertexAttribIuiv(index, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribIuiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetVertexAttribIuiv");
            return false;
        }
    }

    bool Gles::callGlGetVertexAttribPointerv(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void**>();
        auto pname = stack->pop<GLenum>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetVertexAttribPointerv(%" PRIu32 ", %u, %p)", index, pname, pointer);
            if (glGetVertexAttribPointerv != nullptr) {
                glGetVertexAttribPointerv(index, pname, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribPointerv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetVertexAttribPointerv");
            return false;
        }
    }

    bool Gles::callGlGetVertexAttribfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetVertexAttribfv(%" PRIu32 ", %u, %p)", index, pname, params);
            if (glGetVertexAttribfv != nullptr) {
                glGetVertexAttribfv(index, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetVertexAttribfv");
            return false;
        }
    }

    bool Gles::callGlGetVertexAttribiv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetVertexAttribiv(%" PRIu32 ", %u, %p)", index, pname, params);
            if (glGetVertexAttribiv != nullptr) {
                glGetVertexAttribiv(index, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetVertexAttribiv");
            return false;
        }
    }

    bool Gles::callGlIsVertexArray(Stack* stack, bool pushReturn) {
        auto array = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsVertexArray(%" PRIu32 ")", array);
            if (glIsVertexArray != nullptr) {
                GLboolean return_value = glIsVertexArray(array);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsVertexArray");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsVertexArray");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib1f(Stack* stack, bool pushReturn) {
        auto value0 = stack->pop<float>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib1f(%" PRIu32 ", %f)", location, value0);
            if (glVertexAttrib1f != nullptr) {
                glVertexAttrib1f(location, value0);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib1f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib1f");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib1fv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib1fv(%" PRIu32 ", %p)", location, value);
            if (glVertexAttrib1fv != nullptr) {
                glVertexAttrib1fv(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib1fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib1fv");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib2f(Stack* stack, bool pushReturn) {
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib2f(%" PRIu32 ", %f, %f)", location, value0, value1);
            if (glVertexAttrib2f != nullptr) {
                glVertexAttrib2f(location, value0, value1);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib2f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib2f");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib2fv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib2fv(%" PRIu32 ", %p)", location, value);
            if (glVertexAttrib2fv != nullptr) {
                glVertexAttrib2fv(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib2fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib2fv");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib3f(Stack* stack, bool pushReturn) {
        auto value2 = stack->pop<float>();
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib3f(%" PRIu32 ", %f, %f, %f)", location, value0, value1, value2);
            if (glVertexAttrib3f != nullptr) {
                glVertexAttrib3f(location, value0, value1, value2);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib3f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib3f");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib3fv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib3fv(%" PRIu32 ", %p)", location, value);
            if (glVertexAttrib3fv != nullptr) {
                glVertexAttrib3fv(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib3fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib3fv");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib4f(Stack* stack, bool pushReturn) {
        auto value3 = stack->pop<float>();
        auto value2 = stack->pop<float>();
        auto value1 = stack->pop<float>();
        auto value0 = stack->pop<float>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib4f(%" PRIu32 ", %f, %f, %f, %f)", location, value0, value1, value2, value3);
            if (glVertexAttrib4f != nullptr) {
                glVertexAttrib4f(location, value0, value1, value2, value3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib4f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib4f");
            return false;
        }
    }

    bool Gles::callGlVertexAttrib4fv(Stack* stack, bool pushReturn) {
        auto value = stack->pop<GLfloat*>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttrib4fv(%" PRIu32 ", %p)", location, value);
            if (glVertexAttrib4fv != nullptr) {
                glVertexAttrib4fv(location, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttrib4fv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttrib4fv");
            return false;
        }
    }

    bool Gles::callGlVertexAttribBinding(Stack* stack, bool pushReturn) {
        auto binding_index = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribBinding(%" PRIu32 ", %" PRIu32 ")", index, binding_index);
            if (glVertexAttribBinding != nullptr) {
                glVertexAttribBinding(index, binding_index);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribBinding");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribBinding");
            return false;
        }
    }

    bool Gles::callGlVertexAttribDivisor(Stack* stack, bool pushReturn) {
        auto divisor = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribDivisor(%" PRIu32 ", %" PRIu32 ")", index, divisor);
            if (glVertexAttribDivisor != nullptr) {
                glVertexAttribDivisor(index, divisor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisor");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribDivisor");
            return false;
        }
    }

    bool Gles::callGlVertexAttribFormat(Stack* stack, bool pushReturn) {
        auto relativeoffset = stack->pop<uint32_t>();
        auto normalized = stack->pop<uint8_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribFormat(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRIu32 ")", index, size, type, normalized, relativeoffset);
            if (glVertexAttribFormat != nullptr) {
                glVertexAttribFormat(index, size, type, normalized, relativeoffset);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribFormat");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribFormat");
            return false;
        }
    }

    bool Gles::callGlVertexAttribI4i(Stack* stack, bool pushReturn) {
        auto w = stack->pop<int32_t>();
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribI4i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", index, x, y, z, w);
            if (glVertexAttribI4i != nullptr) {
                glVertexAttribI4i(index, x, y, z, w);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4i");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribI4i");
            return false;
        }
    }

    bool Gles::callGlVertexAttribI4iv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLint*>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribI4iv(%" PRIu32 ", %p)", index, values);
            if (glVertexAttribI4iv != nullptr) {
                glVertexAttribI4iv(index, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4iv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribI4iv");
            return false;
        }
    }

    bool Gles::callGlVertexAttribI4ui(Stack* stack, bool pushReturn) {
        auto w = stack->pop<uint32_t>();
        auto z = stack->pop<uint32_t>();
        auto y = stack->pop<uint32_t>();
        auto x = stack->pop<uint32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribI4ui(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")", index, x, y, z, w);
            if (glVertexAttribI4ui != nullptr) {
                glVertexAttribI4ui(index, x, y, z, w);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4ui");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribI4ui");
            return false;
        }
    }

    bool Gles::callGlVertexAttribI4uiv(Stack* stack, bool pushReturn) {
        auto values = stack->pop<GLuint*>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribI4uiv(%" PRIu32 ", %p)", index, values);
            if (glVertexAttribI4uiv != nullptr) {
                glVertexAttribI4uiv(index, values);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4uiv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribI4uiv");
            return false;
        }
    }

    bool Gles::callGlVertexAttribIFormat(Stack* stack, bool pushReturn) {
        auto relativeoffset = stack->pop<uint32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        auto index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribIFormat(%" PRIu32 ", %" PRId32 ", %u, %" PRIu32 ")", index, size, type, relativeoffset);
            if (glVertexAttribIFormat != nullptr) {
                glVertexAttribIFormat(index, size, type, relativeoffset);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribIFormat");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribIFormat");
            return false;
        }
    }

    bool Gles::callGlVertexAttribIPointer(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribIPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRId32 ", %p)", location, size, type, stride, data);
            if (glVertexAttribIPointer != nullptr) {
                glVertexAttribIPointer(location, size, type, stride, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribIPointer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribIPointer");
            return false;
        }
    }

    bool Gles::callGlVertexAttribPointer(Stack* stack, bool pushReturn) {
        auto data = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto normalized = stack->pop<uint8_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        auto location = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRId32 ", %p)", location, size, type, normalized, stride, data);
            if (glVertexAttribPointer != nullptr) {
                glVertexAttribPointer(location, size, type, normalized, stride, data);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexAttribPointer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexAttribPointer");
            return false;
        }
    }

    bool Gles::callGlVertexBindingDivisor(Stack* stack, bool pushReturn) {
        auto divisor = stack->pop<uint32_t>();
        auto binding_index = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexBindingDivisor(%" PRIu32 ", %" PRIu32 ")", binding_index, divisor);
            if (glVertexBindingDivisor != nullptr) {
                glVertexBindingDivisor(binding_index, divisor);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexBindingDivisor");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexBindingDivisor");
            return false;
        }
    }

    bool Gles::callEglInitialize(Stack* stack, bool pushReturn) {
        auto minor = stack->pop<EGLint*>();
        auto major = stack->pop<EGLint*>();
        auto dpy = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglInitialize(%p, %p, %p)", dpy, major, minor);
            if (eglInitialize != nullptr) {
                EGLBoolean return_value = eglInitialize(dpy, major, minor);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglInitialize");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglInitialize");
            return false;
        }
    }

    bool Gles::callEglCreateContext(Stack* stack, bool pushReturn) {
        auto attrib_list = stack->pop<EGLint*>();
        auto share_context = stack->pop<void*>();
        auto config = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglCreateContext(%p, %p, %p, %p)", display, config, share_context, attrib_list);
            if (eglCreateContext != nullptr) {
                EGLContext return_value = eglCreateContext(display, config, share_context, attrib_list);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<EGLContext>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglCreateContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglCreateContext");
            return false;
        }
    }

    bool Gles::callEglMakeCurrent(Stack* stack, bool pushReturn) {
        auto context = stack->pop<void*>();
        auto read = stack->pop<void*>();
        auto draw = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglMakeCurrent(%p, %p, %p, %p)", display, draw, read, context);
            if (eglMakeCurrent != nullptr) {
                EGLBoolean return_value = eglMakeCurrent(display, draw, read, context);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglMakeCurrent");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglMakeCurrent");
            return false;
        }
    }

    bool Gles::callEglSwapBuffers(Stack* stack, bool pushReturn) {
        auto surface = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglSwapBuffers(%p, %p)", display, surface);
            if (eglSwapBuffers != nullptr) {
                EGLBoolean return_value = eglSwapBuffers(display, surface);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglSwapBuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglSwapBuffers");
            return false;
        }
    }

    bool Gles::callEglSwapBuffersWithDamageKHR(Stack* stack, bool pushReturn) {
        auto n_rects = stack->pop<int>();
        auto rects = stack->pop<EGLint*>();
        auto surface = stack->pop<void*>();
        auto dpy = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglSwapBuffersWithDamageKHR(%p, %p, %p, %d)", dpy, surface, rects, n_rects);
            if (eglSwapBuffersWithDamageKHR != nullptr) {
                EGLBoolean return_value = eglSwapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglSwapBuffersWithDamageKHR");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglSwapBuffersWithDamageKHR");
            return false;
        }
    }

    bool Gles::callEglQuerySurface(Stack* stack, bool pushReturn) {
        auto value = stack->pop<EGLint*>();
        auto attribute = stack->pop<int>();
        auto surface = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglQuerySurface(%p, %p, %d, %p)", display, surface, attribute, value);
            if (eglQuerySurface != nullptr) {
                EGLBoolean return_value = eglQuerySurface(display, surface, attribute, value);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglQuerySurface");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglQuerySurface");
            return false;
        }
    }

    bool Gles::callEglQueryContext(Stack* stack, bool pushReturn) {
        auto value = stack->pop<EGLint*>();
        auto attribute = stack->pop<int>();
        auto context = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglQueryContext(%p, %p, %d, %p)", display, context, attribute, value);
            if (eglQueryContext != nullptr) {
                EGLBoolean return_value = eglQueryContext(display, context, attribute, value);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglQueryContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglQueryContext");
            return false;
        }
    }

    bool Gles::callEglChooseConfig(Stack* stack, bool pushReturn) {
        auto num_config = stack->pop<EGLint*>();
        auto config_size = stack->pop<int>();
        auto configs = stack->pop<EGLConfig*>();
        auto attrib_list = stack->pop<EGLint*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglChooseConfig(%p, %p, %p, %d, %p)", display, attrib_list, configs, config_size, num_config);
            if (eglChooseConfig != nullptr) {
                EGLBoolean return_value = eglChooseConfig(display, attrib_list, configs, config_size, num_config);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglChooseConfig");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglChooseConfig");
            return false;
        }
    }

    bool Gles::callEglGetConfigAttrib(Stack* stack, bool pushReturn) {
        auto value = stack->pop<EGLint*>();
        auto attribute = stack->pop<int>();
        auto config = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("eglGetConfigAttrib(%p, %p, %d, %p)", display, config, attribute, value);
            if (eglGetConfigAttrib != nullptr) {
                EGLBoolean return_value = eglGetConfigAttrib(display, config, attribute, value);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<EGLBoolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function eglGetConfigAttrib");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function eglGetConfigAttrib");
            return false;
        }
    }

    bool Gles::callGlXCreateContext(Stack* stack, bool pushReturn) {
        auto direct = stack->pop<bool>();
        auto shareList = stack->pop<void*>();
        auto vis = stack->pop<void*>();
        auto dpy = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glXCreateContext(%p, %p, %p, %d)", dpy, vis, shareList, direct);
            if (glXCreateContext != nullptr) {
                GLXContext return_value = glXCreateContext(dpy, vis, shareList, direct);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<GLXContext>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glXCreateContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glXCreateContext");
            return false;
        }
    }

    bool Gles::callGlXCreateNewContext(Stack* stack, bool pushReturn) {
        auto direct = stack->pop<bool>();
        auto shared = stack->pop<void*>();
        auto type = stack->pop<uint32_t>();
        auto fbconfig = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glXCreateNewContext(%p, %p, %" PRIu32 ", %p, %d)", display, fbconfig, type, shared, direct);
            if (glXCreateNewContext != nullptr) {
                GLXContext return_value = glXCreateNewContext(display, fbconfig, type, shared, direct);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<GLXContext>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glXCreateNewContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glXCreateNewContext");
            return false;
        }
    }

    bool Gles::callGlXMakeContextCurrent(Stack* stack, bool pushReturn) {
        auto ctx = stack->pop<void*>();
        auto read = stack->pop<void*>();
        auto draw = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glXMakeContextCurrent(%p, %p, %p, %p)", display, draw, read, ctx);
            if (glXMakeContextCurrent != nullptr) {
                Bool return_value = glXMakeContextCurrent(display, draw, read, ctx);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<Bool>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glXMakeContextCurrent");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glXMakeContextCurrent");
            return false;
        }
    }

    bool Gles::callGlXMakeCurrent(Stack* stack, bool pushReturn) {
        auto ctx = stack->pop<void*>();
        auto drawable = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glXMakeCurrent(%p, %p, %p)", display, drawable, ctx);
            if (glXMakeCurrent != nullptr) {
                Bool return_value = glXMakeCurrent(display, drawable, ctx);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<Bool>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glXMakeCurrent");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glXMakeCurrent");
            return false;
        }
    }

    bool Gles::callGlXSwapBuffers(Stack* stack, bool pushReturn) {
        auto drawable = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glXSwapBuffers(%p, %p)", display, drawable);
            if (glXSwapBuffers != nullptr) {
                glXSwapBuffers(display, drawable);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glXSwapBuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glXSwapBuffers");
            return false;
        }
    }

    bool Gles::callGlXQueryDrawable(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int*>();
        auto attribute = stack->pop<int>();
        auto draw = stack->pop<void*>();
        auto display = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("glXQueryDrawable(%p, %p, %d, %p)", display, draw, attribute, value);
            if (glXQueryDrawable != nullptr) {
                int return_value = glXQueryDrawable(display, draw, attribute, value);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<int>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glXQueryDrawable");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glXQueryDrawable");
            return false;
        }
    }

    bool Gles::callWglCreateContext(Stack* stack, bool pushReturn) {
        auto hdc = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("wglCreateContext(%p)", hdc);
            if (wglCreateContext != nullptr) {
                HGLRC return_value = wglCreateContext(hdc);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<HGLRC>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function wglCreateContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function wglCreateContext");
            return false;
        }
    }

    bool Gles::callWglCreateContextAttribsARB(Stack* stack, bool pushReturn) {
        auto attribList = stack->pop<int*>();
        auto hShareContext = stack->pop<void*>();
        auto hdc = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("wglCreateContextAttribsARB(%p, %p, %p)", hdc, hShareContext, attribList);
            if (wglCreateContextAttribsARB != nullptr) {
                HGLRC return_value = wglCreateContextAttribsARB(hdc, hShareContext, attribList);
                GAPID_INFO("Returned: %p", return_value);
                if (pushReturn) {
                    stack->push<HGLRC>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function wglCreateContextAttribsARB");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function wglCreateContextAttribsARB");
            return false;
        }
    }

    bool Gles::callWglMakeCurrent(Stack* stack, bool pushReturn) {
        auto hglrc = stack->pop<void*>();
        auto hdc = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("wglMakeCurrent(%p, %p)", hdc, hglrc);
            if (wglMakeCurrent != nullptr) {
                BOOL return_value = wglMakeCurrent(hdc, hglrc);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<BOOL>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function wglMakeCurrent");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function wglMakeCurrent");
            return false;
        }
    }

    bool Gles::callWglSwapBuffers(Stack* stack, bool pushReturn) {
        auto hdc = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("wglSwapBuffers(%p)", hdc);
            if (wglSwapBuffers != nullptr) {
                wglSwapBuffers(hdc);
            } else {
                GAPID_WARNING("Attempted to call unsupported function wglSwapBuffers");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function wglSwapBuffers");
            return false;
        }
    }

    bool Gles::callCGLCreateContext(Stack* stack, bool pushReturn) {
        auto ctx = stack->pop<CGLContextObj*>();
        auto share = stack->pop<void*>();
        auto pix = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("CGLCreateContext(%p, %p, %p)", pix, share, ctx);
            if (CGLCreateContext != nullptr) {
                CGLError return_value = CGLCreateContext(pix, share, ctx);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<CGLError>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function CGLCreateContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function CGLCreateContext");
            return false;
        }
    }

    bool Gles::callCGLSetCurrentContext(Stack* stack, bool pushReturn) {
        auto ctx = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("CGLSetCurrentContext(%p)", ctx);
            if (CGLSetCurrentContext != nullptr) {
                CGLError return_value = CGLSetCurrentContext(ctx);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<CGLError>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function CGLSetCurrentContext");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function CGLSetCurrentContext");
            return false;
        }
    }

    bool Gles::callCGLGetSurface(Stack* stack, bool pushReturn) {
        auto sid = stack->pop<CGSSurfaceID*>();
        auto wid = stack->pop<CGSWindowID*>();
        auto cid = stack->pop<CGSConnectionID*>();
        auto ctx = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("CGLGetSurface(%p, %p, %p, %p)", ctx, cid, wid, sid);
            if (CGLGetSurface != nullptr) {
                int return_value = CGLGetSurface(ctx, cid, wid, sid);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<int>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function CGLGetSurface");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function CGLGetSurface");
            return false;
        }
    }

    bool Gles::callCGSGetSurfaceBounds(Stack* stack, bool pushReturn) {
        auto bounds = stack->pop<double*>();
        auto sid = stack->pop<int32_t>();
        auto wid = stack->pop<int32_t>();
        auto cid = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("CGSGetSurfaceBounds(%p, %" PRId32 ", %" PRId32 ", %p)", cid, wid, sid, bounds);
            if (CGSGetSurfaceBounds != nullptr) {
                int return_value = CGSGetSurfaceBounds(cid, wid, sid, bounds);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<int>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function CGSGetSurfaceBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function CGSGetSurfaceBounds");
            return false;
        }
    }

    bool Gles::callCGLFlushDrawable(Stack* stack, bool pushReturn) {
        auto ctx = stack->pop<void*>();
        if (stack->isValid()) {
            GAPID_INFO("CGLFlushDrawable(%p)", ctx);
            if (CGLFlushDrawable != nullptr) {
                CGLError return_value = CGLFlushDrawable(ctx);
                GAPID_INFO("Returned: %d", return_value);
                if (pushReturn) {
                    stack->push<CGLError>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function CGLFlushDrawable");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function CGLFlushDrawable");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjecti64v(Stack* stack, bool pushReturn) {
        auto value = stack->pop<int64_t*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjecti64v(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjecti64v != nullptr) {
                glGetQueryObjecti64v(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjecti64v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjecti64v");
            return false;
        }
    }

    bool Gles::callGlGetQueryObjectui64v(Stack* stack, bool pushReturn) {
        auto value = stack->pop<uint64_t*>();
        auto parameter = stack->pop<GLenum>();
        auto query = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGetQueryObjectui64v(%" PRIu32 ", %u, %p)", query, parameter, value);
            if (glGetQueryObjectui64v != nullptr) {
                glGetQueryObjectui64v(query, parameter, value);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectui64v");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetQueryObjectui64v");
            return false;
        }
    }

    bool Gles::callGlAlphaFunc(Stack* stack, bool pushReturn) {
        auto ref = stack->pop<float>();
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glAlphaFunc(%u, %f)", func, ref);
            if (glAlphaFunc != nullptr) {
                glAlphaFunc(func, ref);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glAlphaFunc");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glAlphaFunc");
            return false;
        }
    }

    bool Gles::callGlAlphaFuncx(Stack* stack, bool pushReturn) {
        auto ref = stack->pop<int32_t>();
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glAlphaFuncx(%u, %" PRId32 ")", func, ref);
            if (glAlphaFuncx != nullptr) {
                glAlphaFuncx(func, ref);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glAlphaFuncx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glAlphaFuncx");
            return false;
        }
    }

    bool Gles::callGlAlphaFuncxOES(Stack* stack, bool pushReturn) {
        auto ref = stack->pop<int32_t>();
        auto func = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glAlphaFuncxOES(%u, %" PRId32 ")", func, ref);
            if (glAlphaFuncxOES != nullptr) {
                glAlphaFuncxOES(func, ref);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glAlphaFuncxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glAlphaFuncxOES");
            return false;
        }
    }

    bool Gles::callGlBindFramebufferOES(Stack* stack, bool pushReturn) {
        auto framebuffer = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindFramebufferOES(%u, %" PRIu32 ")", target, framebuffer);
            if (glBindFramebufferOES != nullptr) {
                glBindFramebufferOES(target, framebuffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindFramebufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindFramebufferOES");
            return false;
        }
    }

    bool Gles::callGlBindRenderbufferOES(Stack* stack, bool pushReturn) {
        auto renderbuffer = stack->pop<uint32_t>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBindRenderbufferOES(%u, %" PRIu32 ")", target, renderbuffer);
            if (glBindRenderbufferOES != nullptr) {
                glBindRenderbufferOES(target, renderbuffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBindRenderbufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBindRenderbufferOES");
            return false;
        }
    }

    bool Gles::callGlBlendEquationOES(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationOES(%u)", mode);
            if (glBlendEquationOES != nullptr) {
                glBlendEquationOES(mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationOES");
            return false;
        }
    }

    bool Gles::callGlBlendEquationSeparateOES(Stack* stack, bool pushReturn) {
        auto modeAlpha = stack->pop<GLenum>();
        auto modeRGB = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendEquationSeparateOES(%u, %u)", modeRGB, modeAlpha);
            if (glBlendEquationSeparateOES != nullptr) {
                glBlendEquationSeparateOES(modeRGB, modeAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparateOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendEquationSeparateOES");
            return false;
        }
    }

    bool Gles::callGlBlendFuncSeparateOES(Stack* stack, bool pushReturn) {
        auto dstAlpha = stack->pop<GLenum>();
        auto srcAlpha = stack->pop<GLenum>();
        auto dstRGB = stack->pop<GLenum>();
        auto srcRGB = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glBlendFuncSeparateOES(%u, %u, %u, %u)", srcRGB, dstRGB, srcAlpha, dstAlpha);
            if (glBlendFuncSeparateOES != nullptr) {
                glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparateOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glBlendFuncSeparateOES");
            return false;
        }
    }

    bool Gles::callGlCheckFramebufferStatusOES(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glCheckFramebufferStatusOES(%u)", target);
            if (glCheckFramebufferStatusOES != nullptr) {
                GLenum return_value = glCheckFramebufferStatusOES(target);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLenum>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCheckFramebufferStatusOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCheckFramebufferStatusOES");
            return false;
        }
    }

    bool Gles::callGlClearColorx(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<int32_t>();
        auto blue = stack->pop<int32_t>();
        auto green = stack->pop<int32_t>();
        auto red = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glClearColorx(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
            if (glClearColorx != nullptr) {
                glClearColorx(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearColorx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearColorx");
            return false;
        }
    }

    bool Gles::callGlClearColorxOES(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<int32_t>();
        auto blue = stack->pop<int32_t>();
        auto green = stack->pop<int32_t>();
        auto red = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glClearColorxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
            if (glClearColorxOES != nullptr) {
                glClearColorxOES(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearColorxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearColorxOES");
            return false;
        }
    }

    bool Gles::callGlClearDepthfOES(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glClearDepthfOES(%f)", depth);
            if (glClearDepthfOES != nullptr) {
                glClearDepthfOES(depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearDepthfOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearDepthfOES");
            return false;
        }
    }

    bool Gles::callGlClearDepthx(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glClearDepthx(%" PRId32 ")", depth);
            if (glClearDepthx != nullptr) {
                glClearDepthx(depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearDepthx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearDepthx");
            return false;
        }
    }

    bool Gles::callGlClearDepthxOES(Stack* stack, bool pushReturn) {
        auto depth = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glClearDepthxOES(%" PRId32 ")", depth);
            if (glClearDepthxOES != nullptr) {
                glClearDepthxOES(depth);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClearDepthxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClearDepthxOES");
            return false;
        }
    }

    bool Gles::callGlClientActiveTexture(Stack* stack, bool pushReturn) {
        auto texture = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClientActiveTexture(%u)", texture);
            if (glClientActiveTexture != nullptr) {
                glClientActiveTexture(texture);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClientActiveTexture");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClientActiveTexture");
            return false;
        }
    }

    bool Gles::callGlClipPlanef(Stack* stack, bool pushReturn) {
        auto eqn = stack->pop<GLfloat*>();
        auto p = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClipPlanef(%u, %p)", p, eqn);
            if (glClipPlanef != nullptr) {
                glClipPlanef(p, eqn);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClipPlanef");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClipPlanef");
            return false;
        }
    }

    bool Gles::callGlClipPlanefIMG(Stack* stack, bool pushReturn) {
        auto eqn = stack->pop<GLfloat*>();
        auto p = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClipPlanefIMG(%u, %p)", p, eqn);
            if (glClipPlanefIMG != nullptr) {
                glClipPlanefIMG(p, eqn);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClipPlanefIMG");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClipPlanefIMG");
            return false;
        }
    }

    bool Gles::callGlClipPlanefOES(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfloat*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClipPlanefOES(%u, %p)", plane, equation);
            if (glClipPlanefOES != nullptr) {
                glClipPlanefOES(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClipPlanefOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClipPlanefOES");
            return false;
        }
    }

    bool Gles::callGlClipPlanex(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfixed*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClipPlanex(%u, %p)", plane, equation);
            if (glClipPlanex != nullptr) {
                glClipPlanex(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClipPlanex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClipPlanex");
            return false;
        }
    }

    bool Gles::callGlClipPlanexIMG(Stack* stack, bool pushReturn) {
        auto eqn = stack->pop<GLfixed*>();
        auto p = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClipPlanexIMG(%u, %p)", p, eqn);
            if (glClipPlanexIMG != nullptr) {
                glClipPlanexIMG(p, eqn);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClipPlanexIMG");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClipPlanexIMG");
            return false;
        }
    }

    bool Gles::callGlClipPlanexOES(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfixed*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glClipPlanexOES(%u, %p)", plane, equation);
            if (glClipPlanexOES != nullptr) {
                glClipPlanexOES(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glClipPlanexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glClipPlanexOES");
            return false;
        }
    }

    bool Gles::callGlColor4f(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<float>();
        auto blue = stack->pop<float>();
        auto green = stack->pop<float>();
        auto red = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glColor4f(%f, %f, %f, %f)", red, green, blue, alpha);
            if (glColor4f != nullptr) {
                glColor4f(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColor4f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColor4f");
            return false;
        }
    }

    bool Gles::callGlColor4ub(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<uint8_t>();
        auto blue = stack->pop<uint8_t>();
        auto green = stack->pop<uint8_t>();
        auto red = stack->pop<uint8_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColor4ub(%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")", red, green, blue, alpha);
            if (glColor4ub != nullptr) {
                glColor4ub(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColor4ub");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColor4ub");
            return false;
        }
    }

    bool Gles::callGlColor4x(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<int32_t>();
        auto blue = stack->pop<int32_t>();
        auto green = stack->pop<int32_t>();
        auto red = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColor4x(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
            if (glColor4x != nullptr) {
                glColor4x(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColor4x");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColor4x");
            return false;
        }
    }

    bool Gles::callGlColor4xOES(Stack* stack, bool pushReturn) {
        auto alpha = stack->pop<int32_t>();
        auto blue = stack->pop<int32_t>();
        auto green = stack->pop<int32_t>();
        auto red = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColor4xOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", red, green, blue, alpha);
            if (glColor4xOES != nullptr) {
                glColor4xOES(red, green, blue, alpha);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColor4xOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColor4xOES");
            return false;
        }
    }

    bool Gles::callGlColorPointer(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColorPointer(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
            if (glColorPointer != nullptr) {
                glColorPointer(size, type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColorPointer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColorPointer");
            return false;
        }
    }

    bool Gles::callGlCurrentPaletteMatrixOES(Stack* stack, bool pushReturn) {
        auto matrixpaletteindex = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glCurrentPaletteMatrixOES(%" PRIu32 ")", matrixpaletteindex);
            if (glCurrentPaletteMatrixOES != nullptr) {
                glCurrentPaletteMatrixOES(matrixpaletteindex);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glCurrentPaletteMatrixOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glCurrentPaletteMatrixOES");
            return false;
        }
    }

    bool Gles::callGlDeleteFramebuffersOES(Stack* stack, bool pushReturn) {
        auto framebuffers = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteFramebuffersOES(%" PRId32 ", %p)", n, framebuffers);
            if (glDeleteFramebuffersOES != nullptr) {
                glDeleteFramebuffersOES(n, framebuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteFramebuffersOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteFramebuffersOES");
            return false;
        }
    }

    bool Gles::callGlDeleteRenderbuffersOES(Stack* stack, bool pushReturn) {
        auto renderbuffers = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDeleteRenderbuffersOES(%" PRId32 ", %p)", n, renderbuffers);
            if (glDeleteRenderbuffersOES != nullptr) {
                glDeleteRenderbuffersOES(n, renderbuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDeleteRenderbuffersOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDeleteRenderbuffersOES");
            return false;
        }
    }

    bool Gles::callGlDepthRangefOES(Stack* stack, bool pushReturn) {
        auto f = stack->pop<float>();
        auto n = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthRangefOES(%f, %f)", n, f);
            if (glDepthRangefOES != nullptr) {
                glDepthRangefOES(n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthRangefOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthRangefOES");
            return false;
        }
    }

    bool Gles::callGlDepthRangex(Stack* stack, bool pushReturn) {
        auto f = stack->pop<int32_t>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthRangex(%" PRId32 ", %" PRId32 ")", n, f);
            if (glDepthRangex != nullptr) {
                glDepthRangex(n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthRangex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthRangex");
            return false;
        }
    }

    bool Gles::callGlDepthRangexOES(Stack* stack, bool pushReturn) {
        auto f = stack->pop<int32_t>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDepthRangexOES(%" PRId32 ", %" PRId32 ")", n, f);
            if (glDepthRangexOES != nullptr) {
                glDepthRangexOES(n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDepthRangexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDepthRangexOES");
            return false;
        }
    }

    bool Gles::callGlDisableClientState(Stack* stack, bool pushReturn) {
        auto array = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glDisableClientState(%u)", array);
            if (glDisableClientState != nullptr) {
                glDisableClientState(array);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDisableClientState");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDisableClientState");
            return false;
        }
    }

    bool Gles::callGlDrawTexfOES(Stack* stack, bool pushReturn) {
        auto height = stack->pop<float>();
        auto width = stack->pop<float>();
        auto z = stack->pop<float>();
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexfOES(%f, %f, %f, %f, %f)", x, y, z, width, height);
            if (glDrawTexfOES != nullptr) {
                glDrawTexfOES(x, y, z, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexfOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexfOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexfvOES(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<GLfloat*>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexfvOES(%p)", coords);
            if (glDrawTexfvOES != nullptr) {
                glDrawTexfvOES(coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexfvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexfvOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexiOES(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexiOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z, width, height);
            if (glDrawTexiOES != nullptr) {
                glDrawTexiOES(x, y, z, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexiOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexiOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexivOES(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<GLint*>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexivOES(%p)", coords);
            if (glDrawTexivOES != nullptr) {
                glDrawTexivOES(coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexivOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexsOES(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int16_t>();
        auto width = stack->pop<int16_t>();
        auto z = stack->pop<int16_t>();
        auto y = stack->pop<int16_t>();
        auto x = stack->pop<int16_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexsOES(%" PRId16 ", %" PRId16 ", %" PRId16 ", %" PRId16 ", %" PRId16 ")", x, y, z, width, height);
            if (glDrawTexsOES != nullptr) {
                glDrawTexsOES(x, y, z, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexsOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexsOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexsvOES(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<GLshort*>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexsvOES(%p)", coords);
            if (glDrawTexsvOES != nullptr) {
                glDrawTexsvOES(coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexsvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexsvOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexxOES(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z, width, height);
            if (glDrawTexxOES != nullptr) {
                glDrawTexxOES(x, y, z, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexxOES");
            return false;
        }
    }

    bool Gles::callGlDrawTexxvOES(Stack* stack, bool pushReturn) {
        auto coords = stack->pop<GLfixed*>();
        if (stack->isValid()) {
            GAPID_INFO("glDrawTexxvOES(%p)", coords);
            if (glDrawTexxvOES != nullptr) {
                glDrawTexxvOES(coords);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glDrawTexxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glDrawTexxvOES");
            return false;
        }
    }

    bool Gles::callGlEnableClientState(Stack* stack, bool pushReturn) {
        auto array = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glEnableClientState(%u)", array);
            if (glEnableClientState != nullptr) {
                glEnableClientState(array);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glEnableClientState");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glEnableClientState");
            return false;
        }
    }

    bool Gles::callGlFogf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFogf(%u, %f)", pname, param);
            if (glFogf != nullptr) {
                glFogf(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFogf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFogf");
            return false;
        }
    }

    bool Gles::callGlFogfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFogfv(%u, %p)", pname, params);
            if (glFogfv != nullptr) {
                glFogfv(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFogfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFogfv");
            return false;
        }
    }

    bool Gles::callGlFogx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFogx(%u, %" PRId32 ")", pname, param);
            if (glFogx != nullptr) {
                glFogx(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFogx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFogx");
            return false;
        }
    }

    bool Gles::callGlFogxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFogxOES(%u, %" PRId32 ")", pname, param);
            if (glFogxOES != nullptr) {
                glFogxOES(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFogxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFogxOES");
            return false;
        }
    }

    bool Gles::callGlFogxv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFogxv(%u, %p)", pname, param);
            if (glFogxv != nullptr) {
                glFogxv(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFogxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFogxv");
            return false;
        }
    }

    bool Gles::callGlFogxvOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFogxvOES(%u, %p)", pname, param);
            if (glFogxvOES != nullptr) {
                glFogxvOES(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFogxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFogxvOES");
            return false;
        }
    }

    bool Gles::callGlFramebufferRenderbufferOES(Stack* stack, bool pushReturn) {
        auto renderbuffer = stack->pop<uint32_t>();
        auto renderbuffertarget = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferRenderbufferOES(%u, %u, %u, %" PRIu32 ")", target, attachment, renderbuffertarget, renderbuffer);
            if (glFramebufferRenderbufferOES != nullptr) {
                glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferRenderbufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferRenderbufferOES");
            return false;
        }
    }

    bool Gles::callGlFramebufferTexture2DOES(Stack* stack, bool pushReturn) {
        auto level = stack->pop<int32_t>();
        auto texture = stack->pop<uint32_t>();
        auto textarget = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glFramebufferTexture2DOES(%u, %u, %u, %" PRIu32 ", %" PRId32 ")", target, attachment, textarget, texture, level);
            if (glFramebufferTexture2DOES != nullptr) {
                glFramebufferTexture2DOES(target, attachment, textarget, texture, level);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture2DOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFramebufferTexture2DOES");
            return false;
        }
    }

    bool Gles::callGlFrustumf(Stack* stack, bool pushReturn) {
        auto f = stack->pop<float>();
        auto n = stack->pop<float>();
        auto t = stack->pop<float>();
        auto b = stack->pop<float>();
        auto r = stack->pop<float>();
        auto l = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glFrustumf(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
            if (glFrustumf != nullptr) {
                glFrustumf(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFrustumf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFrustumf");
            return false;
        }
    }

    bool Gles::callGlFrustumfOES(Stack* stack, bool pushReturn) {
        auto f = stack->pop<float>();
        auto n = stack->pop<float>();
        auto t = stack->pop<float>();
        auto b = stack->pop<float>();
        auto r = stack->pop<float>();
        auto l = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glFrustumfOES(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
            if (glFrustumfOES != nullptr) {
                glFrustumfOES(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFrustumfOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFrustumfOES");
            return false;
        }
    }

    bool Gles::callGlFrustumx(Stack* stack, bool pushReturn) {
        auto f = stack->pop<int32_t>();
        auto n = stack->pop<int32_t>();
        auto t = stack->pop<int32_t>();
        auto b = stack->pop<int32_t>();
        auto r = stack->pop<int32_t>();
        auto l = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glFrustumx(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
            if (glFrustumx != nullptr) {
                glFrustumx(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFrustumx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFrustumx");
            return false;
        }
    }

    bool Gles::callGlFrustumxOES(Stack* stack, bool pushReturn) {
        auto f = stack->pop<int32_t>();
        auto n = stack->pop<int32_t>();
        auto t = stack->pop<int32_t>();
        auto b = stack->pop<int32_t>();
        auto r = stack->pop<int32_t>();
        auto l = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glFrustumxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
            if (glFrustumxOES != nullptr) {
                glFrustumxOES(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glFrustumxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glFrustumxOES");
            return false;
        }
    }

    bool Gles::callGlGenFramebuffersOES(Stack* stack, bool pushReturn) {
        auto framebuffers = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenFramebuffersOES(%" PRId32 ", %p)", n, framebuffers);
            if (glGenFramebuffersOES != nullptr) {
                glGenFramebuffersOES(n, framebuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenFramebuffersOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenFramebuffersOES");
            return false;
        }
    }

    bool Gles::callGlGenRenderbuffersOES(Stack* stack, bool pushReturn) {
        auto renderbuffers = stack->pop<GLuint*>();
        auto n = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glGenRenderbuffersOES(%" PRId32 ", %p)", n, renderbuffers);
            if (glGenRenderbuffersOES != nullptr) {
                glGenRenderbuffersOES(n, renderbuffers);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenRenderbuffersOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenRenderbuffersOES");
            return false;
        }
    }

    bool Gles::callGlGenerateMipmapOES(Stack* stack, bool pushReturn) {
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGenerateMipmapOES(%u)", target);
            if (glGenerateMipmapOES != nullptr) {
                glGenerateMipmapOES(target);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGenerateMipmapOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGenerateMipmapOES");
            return false;
        }
    }

    bool Gles::callGlGetClipPlanef(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfloat*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetClipPlanef(%u, %p)", plane, equation);
            if (glGetClipPlanef != nullptr) {
                glGetClipPlanef(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetClipPlanef");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetClipPlanef");
            return false;
        }
    }

    bool Gles::callGlGetClipPlanefOES(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfloat*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetClipPlanefOES(%u, %p)", plane, equation);
            if (glGetClipPlanefOES != nullptr) {
                glGetClipPlanefOES(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetClipPlanefOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetClipPlanefOES");
            return false;
        }
    }

    bool Gles::callGlGetClipPlanex(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfixed*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetClipPlanex(%u, %p)", plane, equation);
            if (glGetClipPlanex != nullptr) {
                glGetClipPlanex(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetClipPlanex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetClipPlanex");
            return false;
        }
    }

    bool Gles::callGlGetClipPlanexOES(Stack* stack, bool pushReturn) {
        auto equation = stack->pop<GLfixed*>();
        auto plane = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetClipPlanexOES(%u, %p)", plane, equation);
            if (glGetClipPlanexOES != nullptr) {
                glGetClipPlanexOES(plane, equation);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetClipPlanexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetClipPlanexOES");
            return false;
        }
    }

    bool Gles::callGlGetFixedv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFixedv(%u, %p)", pname, params);
            if (glGetFixedv != nullptr) {
                glGetFixedv(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFixedv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFixedv");
            return false;
        }
    }

    bool Gles::callGlGetFixedvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFixedvOES(%u, %p)", pname, params);
            if (glGetFixedvOES != nullptr) {
                glGetFixedvOES(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFixedvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFixedvOES");
            return false;
        }
    }

    bool Gles::callGlGetFramebufferAttachmentParameterivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto attachment = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetFramebufferAttachmentParameterivOES(%u, %u, %u, %p)", target, attachment, pname, params);
            if (glGetFramebufferAttachmentParameterivOES != nullptr) {
                glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetFramebufferAttachmentParameterivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetFramebufferAttachmentParameterivOES");
            return false;
        }
    }

    bool Gles::callGlGetLightfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetLightfv(%u, %u, %p)", light, pname, params);
            if (glGetLightfv != nullptr) {
                glGetLightfv(light, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetLightfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetLightfv");
            return false;
        }
    }

    bool Gles::callGlGetLightxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetLightxv(%u, %u, %p)", light, pname, params);
            if (glGetLightxv != nullptr) {
                glGetLightxv(light, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetLightxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetLightxv");
            return false;
        }
    }

    bool Gles::callGlGetLightxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetLightxvOES(%u, %u, %p)", light, pname, params);
            if (glGetLightxvOES != nullptr) {
                glGetLightxvOES(light, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetLightxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetLightxvOES");
            return false;
        }
    }

    bool Gles::callGlGetMaterialfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetMaterialfv(%u, %u, %p)", face, pname, params);
            if (glGetMaterialfv != nullptr) {
                glGetMaterialfv(face, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetMaterialfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetMaterialfv");
            return false;
        }
    }

    bool Gles::callGlGetMaterialxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetMaterialxv(%u, %u, %p)", face, pname, params);
            if (glGetMaterialxv != nullptr) {
                glGetMaterialxv(face, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetMaterialxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetMaterialxv");
            return false;
        }
    }

    bool Gles::callGlGetMaterialxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetMaterialxvOES(%u, %u, %p)", face, pname, params);
            if (glGetMaterialxvOES != nullptr) {
                glGetMaterialxvOES(face, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetMaterialxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetMaterialxvOES");
            return false;
        }
    }

    bool Gles::callGlGetRenderbufferParameterivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetRenderbufferParameterivOES(%u, %u, %p)", target, pname, params);
            if (glGetRenderbufferParameterivOES != nullptr) {
                glGetRenderbufferParameterivOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetRenderbufferParameterivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetRenderbufferParameterivOES");
            return false;
        }
    }

    bool Gles::callGlGetTexEnvfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexEnvfv(%u, %u, %p)", target, pname, params);
            if (glGetTexEnvfv != nullptr) {
                glGetTexEnvfv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexEnvfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexEnvfv");
            return false;
        }
    }

    bool Gles::callGlGetTexEnviv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexEnviv(%u, %u, %p)", target, pname, params);
            if (glGetTexEnviv != nullptr) {
                glGetTexEnviv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexEnviv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexEnviv");
            return false;
        }
    }

    bool Gles::callGlGetTexEnvxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexEnvxv(%u, %u, %p)", target, pname, params);
            if (glGetTexEnvxv != nullptr) {
                glGetTexEnvxv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexEnvxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexEnvxv");
            return false;
        }
    }

    bool Gles::callGlGetTexEnvxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexEnvxvOES(%u, %u, %p)", target, pname, params);
            if (glGetTexEnvxvOES != nullptr) {
                glGetTexEnvxvOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexEnvxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexEnvxvOES");
            return false;
        }
    }

    bool Gles::callGlGetTexGenfvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexGenfvOES(%u, %u, %p)", coord, pname, params);
            if (glGetTexGenfvOES != nullptr) {
                glGetTexGenfvOES(coord, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexGenfvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexGenfvOES");
            return false;
        }
    }

    bool Gles::callGlGetTexGenivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexGenivOES(%u, %u, %p)", coord, pname, params);
            if (glGetTexGenivOES != nullptr) {
                glGetTexGenivOES(coord, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexGenivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexGenivOES");
            return false;
        }
    }

    bool Gles::callGlGetTexGenxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexGenxvOES(%u, %u, %p)", coord, pname, params);
            if (glGetTexGenxvOES != nullptr) {
                glGetTexGenxvOES(coord, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexGenxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexGenxvOES");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterxv(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterxv != nullptr) {
                glGetTexParameterxv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterxv");
            return false;
        }
    }

    bool Gles::callGlGetTexParameterxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glGetTexParameterxvOES(%u, %u, %p)", target, pname, params);
            if (glGetTexParameterxvOES != nullptr) {
                glGetTexParameterxvOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glGetTexParameterxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glGetTexParameterxvOES");
            return false;
        }
    }

    bool Gles::callGlIsFramebufferOES(Stack* stack, bool pushReturn) {
        auto framebuffer = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsFramebufferOES(%" PRIu32 ")", framebuffer);
            if (glIsFramebufferOES != nullptr) {
                GLboolean return_value = glIsFramebufferOES(framebuffer);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsFramebufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsFramebufferOES");
            return false;
        }
    }

    bool Gles::callGlIsRenderbufferOES(Stack* stack, bool pushReturn) {
        auto renderbuffer = stack->pop<uint32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glIsRenderbufferOES(%" PRIu32 ")", renderbuffer);
            if (glIsRenderbufferOES != nullptr) {
                GLboolean return_value = glIsRenderbufferOES(renderbuffer);
                GAPID_INFO("Returned: %" PRIu8 "", return_value);
                if (pushReturn) {
                    stack->push<GLboolean>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glIsRenderbufferOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glIsRenderbufferOES");
            return false;
        }
    }

    bool Gles::callGlLightModelf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightModelf(%u, %f)", pname, param);
            if (glLightModelf != nullptr) {
                glLightModelf(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightModelf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightModelf");
            return false;
        }
    }

    bool Gles::callGlLightModelfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightModelfv(%u, %p)", pname, params);
            if (glLightModelfv != nullptr) {
                glLightModelfv(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightModelfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightModelfv");
            return false;
        }
    }

    bool Gles::callGlLightModelx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightModelx(%u, %" PRId32 ")", pname, param);
            if (glLightModelx != nullptr) {
                glLightModelx(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightModelx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightModelx");
            return false;
        }
    }

    bool Gles::callGlLightModelxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightModelxOES(%u, %" PRId32 ")", pname, param);
            if (glLightModelxOES != nullptr) {
                glLightModelxOES(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightModelxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightModelxOES");
            return false;
        }
    }

    bool Gles::callGlLightModelxv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightModelxv(%u, %p)", pname, param);
            if (glLightModelxv != nullptr) {
                glLightModelxv(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightModelxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightModelxv");
            return false;
        }
    }

    bool Gles::callGlLightModelxvOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightModelxvOES(%u, %p)", pname, param);
            if (glLightModelxvOES != nullptr) {
                glLightModelxvOES(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightModelxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightModelxvOES");
            return false;
        }
    }

    bool Gles::callGlLightf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightf(%u, %u, %f)", light, pname, param);
            if (glLightf != nullptr) {
                glLightf(light, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightf");
            return false;
        }
    }

    bool Gles::callGlLightfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightfv(%u, %u, %p)", light, pname, params);
            if (glLightfv != nullptr) {
                glLightfv(light, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightfv");
            return false;
        }
    }

    bool Gles::callGlLightx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightx(%u, %u, %" PRId32 ")", light, pname, param);
            if (glLightx != nullptr) {
                glLightx(light, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightx");
            return false;
        }
    }

    bool Gles::callGlLightxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightxOES(%u, %u, %" PRId32 ")", light, pname, param);
            if (glLightxOES != nullptr) {
                glLightxOES(light, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightxOES");
            return false;
        }
    }

    bool Gles::callGlLightxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightxv(%u, %u, %p)", light, pname, params);
            if (glLightxv != nullptr) {
                glLightxv(light, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightxv");
            return false;
        }
    }

    bool Gles::callGlLightxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto light = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLightxvOES(%u, %u, %p)", light, pname, params);
            if (glLightxvOES != nullptr) {
                glLightxvOES(light, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLightxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLightxvOES");
            return false;
        }
    }

    bool Gles::callGlLineWidthx(Stack* stack, bool pushReturn) {
        auto width = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glLineWidthx(%" PRId32 ")", width);
            if (glLineWidthx != nullptr) {
                glLineWidthx(width);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLineWidthx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLineWidthx");
            return false;
        }
    }

    bool Gles::callGlLineWidthxOES(Stack* stack, bool pushReturn) {
        auto width = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glLineWidthxOES(%" PRId32 ")", width);
            if (glLineWidthxOES != nullptr) {
                glLineWidthxOES(width);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLineWidthxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLineWidthxOES");
            return false;
        }
    }

    bool Gles::callGlLoadIdentity(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glLoadIdentity()");
            if (glLoadIdentity != nullptr) {
                glLoadIdentity();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLoadIdentity");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLoadIdentity");
            return false;
        }
    }

    bool Gles::callGlLoadMatrixf(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        if (stack->isValid()) {
            GAPID_INFO("glLoadMatrixf(%p)", m);
            if (glLoadMatrixf != nullptr) {
                glLoadMatrixf(m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLoadMatrixf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLoadMatrixf");
            return false;
        }
    }

    bool Gles::callGlLoadMatrixx(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfixed*>();
        if (stack->isValid()) {
            GAPID_INFO("glLoadMatrixx(%p)", m);
            if (glLoadMatrixx != nullptr) {
                glLoadMatrixx(m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLoadMatrixx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLoadMatrixx");
            return false;
        }
    }

    bool Gles::callGlLoadMatrixxOES(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfixed*>();
        if (stack->isValid()) {
            GAPID_INFO("glLoadMatrixxOES(%p)", m);
            if (glLoadMatrixxOES != nullptr) {
                glLoadMatrixxOES(m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLoadMatrixxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLoadMatrixxOES");
            return false;
        }
    }

    bool Gles::callGlLoadPaletteFromModelViewMatrixOES(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glLoadPaletteFromModelViewMatrixOES()");
            if (glLoadPaletteFromModelViewMatrixOES != nullptr) {
                glLoadPaletteFromModelViewMatrixOES();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLoadPaletteFromModelViewMatrixOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLoadPaletteFromModelViewMatrixOES");
            return false;
        }
    }

    bool Gles::callGlLogicOp(Stack* stack, bool pushReturn) {
        auto opcode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glLogicOp(%u)", opcode);
            if (glLogicOp != nullptr) {
                glLogicOp(opcode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glLogicOp");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glLogicOp");
            return false;
        }
    }

    bool Gles::callGlMaterialf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMaterialf(%u, %u, %f)", face, pname, param);
            if (glMaterialf != nullptr) {
                glMaterialf(face, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMaterialf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMaterialf");
            return false;
        }
    }

    bool Gles::callGlMaterialfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMaterialfv(%u, %u, %p)", face, pname, params);
            if (glMaterialfv != nullptr) {
                glMaterialfv(face, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMaterialfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMaterialfv");
            return false;
        }
    }

    bool Gles::callGlMaterialx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMaterialx(%u, %u, %" PRId32 ")", face, pname, param);
            if (glMaterialx != nullptr) {
                glMaterialx(face, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMaterialx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMaterialx");
            return false;
        }
    }

    bool Gles::callGlMaterialxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMaterialxOES(%u, %u, %" PRId32 ")", face, pname, param);
            if (glMaterialxOES != nullptr) {
                glMaterialxOES(face, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMaterialxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMaterialxOES");
            return false;
        }
    }

    bool Gles::callGlMaterialxv(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMaterialxv(%u, %u, %p)", face, pname, param);
            if (glMaterialxv != nullptr) {
                glMaterialxv(face, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMaterialxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMaterialxv");
            return false;
        }
    }

    bool Gles::callGlMaterialxvOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto face = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMaterialxvOES(%u, %u, %p)", face, pname, param);
            if (glMaterialxvOES != nullptr) {
                glMaterialxvOES(face, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMaterialxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMaterialxvOES");
            return false;
        }
    }

    bool Gles::callGlMatrixIndexPointerOES(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixIndexPointerOES(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
            if (glMatrixIndexPointerOES != nullptr) {
                glMatrixIndexPointerOES(size, type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixIndexPointerOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixIndexPointerOES");
            return false;
        }
    }

    bool Gles::callGlMatrixMode(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixMode(%u)", mode);
            if (glMatrixMode != nullptr) {
                glMatrixMode(mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixMode");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixMode");
            return false;
        }
    }

    bool Gles::callGlMultMatrixf(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfloat*>();
        if (stack->isValid()) {
            GAPID_INFO("glMultMatrixf(%p)", m);
            if (glMultMatrixf != nullptr) {
                glMultMatrixf(m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultMatrixf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultMatrixf");
            return false;
        }
    }

    bool Gles::callGlMultMatrixx(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfixed*>();
        if (stack->isValid()) {
            GAPID_INFO("glMultMatrixx(%p)", m);
            if (glMultMatrixx != nullptr) {
                glMultMatrixx(m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultMatrixx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultMatrixx");
            return false;
        }
    }

    bool Gles::callGlMultMatrixxOES(Stack* stack, bool pushReturn) {
        auto m = stack->pop<GLfixed*>();
        if (stack->isValid()) {
            GAPID_INFO("glMultMatrixxOES(%p)", m);
            if (glMultMatrixxOES != nullptr) {
                glMultMatrixxOES(m);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultMatrixxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultMatrixxOES");
            return false;
        }
    }

    bool Gles::callGlMultiTexCoord4f(Stack* stack, bool pushReturn) {
        auto v3 = stack->pop<float>();
        auto v2 = stack->pop<float>();
        auto v1 = stack->pop<float>();
        auto v0 = stack->pop<float>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiTexCoord4f(%u, %f, %f, %f, %f)", target, v0, v1, v2, v3);
            if (glMultiTexCoord4f != nullptr) {
                glMultiTexCoord4f(target, v0, v1, v2, v3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiTexCoord4f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiTexCoord4f");
            return false;
        }
    }

    bool Gles::callGlMultiTexCoord4x(Stack* stack, bool pushReturn) {
        auto v3 = stack->pop<int32_t>();
        auto v2 = stack->pop<int32_t>();
        auto v1 = stack->pop<int32_t>();
        auto v0 = stack->pop<int32_t>();
        auto texture = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiTexCoord4x(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, v0, v1, v2, v3);
            if (glMultiTexCoord4x != nullptr) {
                glMultiTexCoord4x(texture, v0, v1, v2, v3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiTexCoord4x");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiTexCoord4x");
            return false;
        }
    }

    bool Gles::callGlMultiTexCoord4xOES(Stack* stack, bool pushReturn) {
        auto v3 = stack->pop<int32_t>();
        auto v2 = stack->pop<int32_t>();
        auto v1 = stack->pop<int32_t>();
        auto v0 = stack->pop<int32_t>();
        auto texture = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glMultiTexCoord4xOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", texture, v0, v1, v2, v3);
            if (glMultiTexCoord4xOES != nullptr) {
                glMultiTexCoord4xOES(texture, v0, v1, v2, v3);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMultiTexCoord4xOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMultiTexCoord4xOES");
            return false;
        }
    }

    bool Gles::callGlNormal3f(Stack* stack, bool pushReturn) {
        auto nz = stack->pop<float>();
        auto ny = stack->pop<float>();
        auto nx = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glNormal3f(%f, %f, %f)", nx, ny, nz);
            if (glNormal3f != nullptr) {
                glNormal3f(nx, ny, nz);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glNormal3f");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glNormal3f");
            return false;
        }
    }

    bool Gles::callGlNormal3x(Stack* stack, bool pushReturn) {
        auto nz = stack->pop<int32_t>();
        auto ny = stack->pop<int32_t>();
        auto nx = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glNormal3x(%" PRId32 ", %" PRId32 ", %" PRId32 ")", nx, ny, nz);
            if (glNormal3x != nullptr) {
                glNormal3x(nx, ny, nz);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glNormal3x");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glNormal3x");
            return false;
        }
    }

    bool Gles::callGlNormal3xOES(Stack* stack, bool pushReturn) {
        auto nz = stack->pop<int32_t>();
        auto ny = stack->pop<int32_t>();
        auto nx = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glNormal3xOES(%" PRId32 ", %" PRId32 ", %" PRId32 ")", nx, ny, nz);
            if (glNormal3xOES != nullptr) {
                glNormal3xOES(nx, ny, nz);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glNormal3xOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glNormal3xOES");
            return false;
        }
    }

    bool Gles::callGlNormalPointer(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glNormalPointer(%u, %" PRId32 ", %p)", type, stride, pointer);
            if (glNormalPointer != nullptr) {
                glNormalPointer(type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glNormalPointer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glNormalPointer");
            return false;
        }
    }

    bool Gles::callGlOrthof(Stack* stack, bool pushReturn) {
        auto f = stack->pop<float>();
        auto n = stack->pop<float>();
        auto t = stack->pop<float>();
        auto b = stack->pop<float>();
        auto r = stack->pop<float>();
        auto l = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glOrthof(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
            if (glOrthof != nullptr) {
                glOrthof(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glOrthof");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glOrthof");
            return false;
        }
    }

    bool Gles::callGlOrthofOES(Stack* stack, bool pushReturn) {
        auto f = stack->pop<float>();
        auto n = stack->pop<float>();
        auto t = stack->pop<float>();
        auto b = stack->pop<float>();
        auto r = stack->pop<float>();
        auto l = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glOrthofOES(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f);
            if (glOrthofOES != nullptr) {
                glOrthofOES(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glOrthofOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glOrthofOES");
            return false;
        }
    }

    bool Gles::callGlOrthox(Stack* stack, bool pushReturn) {
        auto f = stack->pop<int32_t>();
        auto n = stack->pop<int32_t>();
        auto t = stack->pop<int32_t>();
        auto b = stack->pop<int32_t>();
        auto r = stack->pop<int32_t>();
        auto l = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glOrthox(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
            if (glOrthox != nullptr) {
                glOrthox(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glOrthox");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glOrthox");
            return false;
        }
    }

    bool Gles::callGlOrthoxOES(Stack* stack, bool pushReturn) {
        auto f = stack->pop<int32_t>();
        auto n = stack->pop<int32_t>();
        auto t = stack->pop<int32_t>();
        auto b = stack->pop<int32_t>();
        auto r = stack->pop<int32_t>();
        auto l = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glOrthoxOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", l, r, b, t, n, f);
            if (glOrthoxOES != nullptr) {
                glOrthoxOES(l, r, b, t, n, f);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glOrthoxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glOrthoxOES");
            return false;
        }
    }

    bool Gles::callGlPointParameterf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointParameterf(%u, %f)", pname, param);
            if (glPointParameterf != nullptr) {
                glPointParameterf(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointParameterf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointParameterf");
            return false;
        }
    }

    bool Gles::callGlPointParameterfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointParameterfv(%u, %p)", pname, params);
            if (glPointParameterfv != nullptr) {
                glPointParameterfv(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointParameterfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointParameterfv");
            return false;
        }
    }

    bool Gles::callGlPointParameterx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointParameterx(%u, %" PRId32 ")", pname, param);
            if (glPointParameterx != nullptr) {
                glPointParameterx(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointParameterx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointParameterx");
            return false;
        }
    }

    bool Gles::callGlPointParameterxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointParameterxOES(%u, %" PRId32 ")", pname, param);
            if (glPointParameterxOES != nullptr) {
                glPointParameterxOES(pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointParameterxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointParameterxOES");
            return false;
        }
    }

    bool Gles::callGlPointParameterxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointParameterxv(%u, %p)", pname, params);
            if (glPointParameterxv != nullptr) {
                glPointParameterxv(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointParameterxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointParameterxv");
            return false;
        }
    }

    bool Gles::callGlPointParameterxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointParameterxvOES(%u, %p)", pname, params);
            if (glPointParameterxvOES != nullptr) {
                glPointParameterxvOES(pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointParameterxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointParameterxvOES");
            return false;
        }
    }

    bool Gles::callGlPointSize(Stack* stack, bool pushReturn) {
        auto size = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glPointSize(%f)", size);
            if (glPointSize != nullptr) {
                glPointSize(size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointSize");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointSize");
            return false;
        }
    }

    bool Gles::callGlPointSizePointerOES(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointSizePointerOES(%u, %" PRId32 ", %p)", type, stride, pointer);
            if (glPointSizePointerOES != nullptr) {
                glPointSizePointerOES(type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointSizePointerOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointSizePointerOES");
            return false;
        }
    }

    bool Gles::callGlPointSizex(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPointSizex(%" PRId32 ")", size);
            if (glPointSizex != nullptr) {
                glPointSizex(size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointSizex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointSizex");
            return false;
        }
    }

    bool Gles::callGlPointSizexOES(Stack* stack, bool pushReturn) {
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPointSizexOES(%" PRId32 ")", size);
            if (glPointSizexOES != nullptr) {
                glPointSizexOES(size);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointSizexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointSizexOES");
            return false;
        }
    }

    bool Gles::callGlPolygonOffsetx(Stack* stack, bool pushReturn) {
        auto units = stack->pop<int32_t>();
        auto factor = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPolygonOffsetx(%" PRId32 ", %" PRId32 ")", factor, units);
            if (glPolygonOffsetx != nullptr) {
                glPolygonOffsetx(factor, units);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPolygonOffsetx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPolygonOffsetx");
            return false;
        }
    }

    bool Gles::callGlPolygonOffsetxOES(Stack* stack, bool pushReturn) {
        auto units = stack->pop<int32_t>();
        auto factor = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glPolygonOffsetxOES(%" PRId32 ", %" PRId32 ")", factor, units);
            if (glPolygonOffsetxOES != nullptr) {
                glPolygonOffsetxOES(factor, units);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPolygonOffsetxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPolygonOffsetxOES");
            return false;
        }
    }

    bool Gles::callGlPopMatrix(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glPopMatrix()");
            if (glPopMatrix != nullptr) {
                glPopMatrix();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPopMatrix");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPopMatrix");
            return false;
        }
    }

    bool Gles::callGlPushMatrix(Stack* stack, bool pushReturn) {
        if (stack->isValid()) {
            GAPID_INFO("glPushMatrix()");
            if (glPushMatrix != nullptr) {
                glPushMatrix();
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPushMatrix");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPushMatrix");
            return false;
        }
    }

    bool Gles::callGlQueryMatrixxOES(Stack* stack, bool pushReturn) {
        auto exponent = stack->pop<GLint*>();
        auto mantissa = stack->pop<GLfixed*>();
        if (stack->isValid()) {
            GAPID_INFO("glQueryMatrixxOES(%p, %p)", mantissa, exponent);
            if (glQueryMatrixxOES != nullptr) {
                GLbitfield return_value = glQueryMatrixxOES(mantissa, exponent);
                GAPID_INFO("Returned: %u", return_value);
                if (pushReturn) {
                    stack->push<GLbitfield>(return_value);
                }
            } else {
                GAPID_WARNING("Attempted to call unsupported function glQueryMatrixxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glQueryMatrixxOES");
            return false;
        }
    }

    bool Gles::callGlRenderbufferStorageOES(Stack* stack, bool pushReturn) {
        auto height = stack->pop<int32_t>();
        auto width = stack->pop<int32_t>();
        auto internalformat = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glRenderbufferStorageOES(%u, %u, %" PRId32 ", %" PRId32 ")", target, internalformat, width, height);
            if (glRenderbufferStorageOES != nullptr) {
                glRenderbufferStorageOES(target, internalformat, width, height);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorageOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRenderbufferStorageOES");
            return false;
        }
    }

    bool Gles::callGlRotatef(Stack* stack, bool pushReturn) {
        auto z = stack->pop<float>();
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        auto angle = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glRotatef(%f, %f, %f, %f)", angle, x, y, z);
            if (glRotatef != nullptr) {
                glRotatef(angle, x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRotatef");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRotatef");
            return false;
        }
    }

    bool Gles::callGlRotatex(Stack* stack, bool pushReturn) {
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto angle = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glRotatex(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", angle, x, y, z);
            if (glRotatex != nullptr) {
                glRotatex(angle, x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRotatex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRotatex");
            return false;
        }
    }

    bool Gles::callGlRotatexOES(Stack* stack, bool pushReturn) {
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        auto angle = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glRotatexOES(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", angle, x, y, z);
            if (glRotatexOES != nullptr) {
                glRotatexOES(angle, x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glRotatexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glRotatexOES");
            return false;
        }
    }

    bool Gles::callGlSampleCoveragex(Stack* stack, bool pushReturn) {
        auto invert = stack->pop<uint8_t>();
        auto value = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSampleCoveragex(%" PRId32 ", %" PRIu8 ")", value, invert);
            if (glSampleCoveragex != nullptr) {
                glSampleCoveragex(value, invert);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSampleCoveragex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSampleCoveragex");
            return false;
        }
    }

    bool Gles::callGlSampleCoveragexOES(Stack* stack, bool pushReturn) {
        auto invert = stack->pop<uint8_t>();
        auto value = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glSampleCoveragexOES(%" PRId32 ", %" PRIu8 ")", value, invert);
            if (glSampleCoveragexOES != nullptr) {
                glSampleCoveragexOES(value, invert);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glSampleCoveragexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glSampleCoveragexOES");
            return false;
        }
    }

    bool Gles::callGlScalef(Stack* stack, bool pushReturn) {
        auto z = stack->pop<float>();
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glScalef(%f, %f, %f)", x, y, z);
            if (glScalef != nullptr) {
                glScalef(x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScalef");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScalef");
            return false;
        }
    }

    bool Gles::callGlScalex(Stack* stack, bool pushReturn) {
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glScalex(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
            if (glScalex != nullptr) {
                glScalex(x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScalex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScalex");
            return false;
        }
    }

    bool Gles::callGlScalexOES(Stack* stack, bool pushReturn) {
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glScalexOES(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
            if (glScalexOES != nullptr) {
                glScalexOES(x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glScalexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glScalexOES");
            return false;
        }
    }

    bool Gles::callGlShadeModel(Stack* stack, bool pushReturn) {
        auto mode = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glShadeModel(%u)", mode);
            if (glShadeModel != nullptr) {
                glShadeModel(mode);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glShadeModel");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glShadeModel");
            return false;
        }
    }

    bool Gles::callGlTexCoordPointer(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTexCoordPointer(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
            if (glTexCoordPointer != nullptr) {
                glTexCoordPointer(size, type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexCoordPointer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexCoordPointer");
            return false;
        }
    }

    bool Gles::callGlTexEnvf(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvf(%u, %u, %f)", target, pname, param);
            if (glTexEnvf != nullptr) {
                glTexEnvf(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvf");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvf");
            return false;
        }
    }

    bool Gles::callGlTexEnvfv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvfv(%u, %u, %p)", target, pname, params);
            if (glTexEnvfv != nullptr) {
                glTexEnvfv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvfv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvfv");
            return false;
        }
    }

    bool Gles::callGlTexEnvi(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvi(%u, %u, %" PRId32 ")", target, pname, param);
            if (glTexEnvi != nullptr) {
                glTexEnvi(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvi");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvi");
            return false;
        }
    }

    bool Gles::callGlTexEnviv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnviv(%u, %u, %p)", target, pname, params);
            if (glTexEnviv != nullptr) {
                glTexEnviv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnviv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnviv");
            return false;
        }
    }

    bool Gles::callGlTexEnvx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvx(%u, %u, %" PRId32 ")", target, pname, param);
            if (glTexEnvx != nullptr) {
                glTexEnvx(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvx");
            return false;
        }
    }

    bool Gles::callGlTexEnvxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvxOES(%u, %u, %" PRId32 ")", target, pname, param);
            if (glTexEnvxOES != nullptr) {
                glTexEnvxOES(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvxOES");
            return false;
        }
    }

    bool Gles::callGlTexEnvxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvxv(%u, %u, %p)", target, pname, params);
            if (glTexEnvxv != nullptr) {
                glTexEnvxv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvxv");
            return false;
        }
    }

    bool Gles::callGlTexEnvxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexEnvxvOES(%u, %u, %p)", target, pname, params);
            if (glTexEnvxvOES != nullptr) {
                glTexEnvxvOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexEnvxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexEnvxvOES");
            return false;
        }
    }

    bool Gles::callGlTexGenfOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<float>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexGenfOES(%u, %u, %f)", coord, pname, param);
            if (glTexGenfOES != nullptr) {
                glTexGenfOES(coord, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexGenfOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexGenfOES");
            return false;
        }
    }

    bool Gles::callGlTexGenfvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfloat*>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexGenfvOES(%u, %u, %p)", coord, pname, params);
            if (glTexGenfvOES != nullptr) {
                glTexGenfvOES(coord, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexGenfvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexGenfvOES");
            return false;
        }
    }

    bool Gles::callGlTexGeniOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexGeniOES(%u, %u, %" PRId32 ")", coord, pname, param);
            if (glTexGeniOES != nullptr) {
                glTexGeniOES(coord, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexGeniOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexGeniOES");
            return false;
        }
    }

    bool Gles::callGlTexGenivOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLint*>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexGenivOES(%u, %u, %p)", coord, pname, params);
            if (glTexGenivOES != nullptr) {
                glTexGenivOES(coord, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexGenivOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexGenivOES");
            return false;
        }
    }

    bool Gles::callGlTexGenxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexGenxOES(%u, %u, %" PRId32 ")", coord, pname, param);
            if (glTexGenxOES != nullptr) {
                glTexGenxOES(coord, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexGenxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexGenxOES");
            return false;
        }
    }

    bool Gles::callGlTexGenxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto coord = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexGenxvOES(%u, %u, %p)", coord, pname, params);
            if (glTexGenxvOES != nullptr) {
                glTexGenxvOES(coord, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexGenxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexGenxvOES");
            return false;
        }
    }

    bool Gles::callGlTexParameterx(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterx(%u, %u, %" PRId32 ")", target, pname, param);
            if (glTexParameterx != nullptr) {
                glTexParameterx(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterx");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterx");
            return false;
        }
    }

    bool Gles::callGlTexParameterxOES(Stack* stack, bool pushReturn) {
        auto param = stack->pop<int32_t>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterxOES(%u, %u, %" PRId32 ")", target, pname, param);
            if (glTexParameterxOES != nullptr) {
                glTexParameterxOES(target, pname, param);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterxOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterxOES");
            return false;
        }
    }

    bool Gles::callGlTexParameterxv(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterxv(%u, %u, %p)", target, pname, params);
            if (glTexParameterxv != nullptr) {
                glTexParameterxv(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterxv");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterxv");
            return false;
        }
    }

    bool Gles::callGlTexParameterxvOES(Stack* stack, bool pushReturn) {
        auto params = stack->pop<GLfixed*>();
        auto pname = stack->pop<GLenum>();
        auto target = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glTexParameterxvOES(%u, %u, %p)", target, pname, params);
            if (glTexParameterxvOES != nullptr) {
                glTexParameterxvOES(target, pname, params);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexParameterxvOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexParameterxvOES");
            return false;
        }
    }

    bool Gles::callGlTranslatef(Stack* stack, bool pushReturn) {
        auto z = stack->pop<float>();
        auto y = stack->pop<float>();
        auto x = stack->pop<float>();
        if (stack->isValid()) {
            GAPID_INFO("glTranslatef(%f, %f, %f)", x, y, z);
            if (glTranslatef != nullptr) {
                glTranslatef(x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTranslatef");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTranslatef");
            return false;
        }
    }

    bool Gles::callGlTranslatex(Stack* stack, bool pushReturn) {
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTranslatex(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
            if (glTranslatex != nullptr) {
                glTranslatex(x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTranslatex");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTranslatex");
            return false;
        }
    }

    bool Gles::callGlTranslatexOES(Stack* stack, bool pushReturn) {
        auto z = stack->pop<int32_t>();
        auto y = stack->pop<int32_t>();
        auto x = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTranslatexOES(%" PRId32 ", %" PRId32 ", %" PRId32 ")", x, y, z);
            if (glTranslatexOES != nullptr) {
                glTranslatexOES(x, y, z);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTranslatexOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTranslatexOES");
            return false;
        }
    }

    bool Gles::callGlVertexPointer(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexPointer(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
            if (glVertexPointer != nullptr) {
                glVertexPointer(size, type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexPointer");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexPointer");
            return false;
        }
    }

    bool Gles::callGlWeightPointerOES(Stack* stack, bool pushReturn) {
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glWeightPointerOES(%" PRId32 ", %u, %" PRId32 ", %p)", size, type, stride, pointer);
            if (glWeightPointerOES != nullptr) {
                glWeightPointerOES(size, type, stride, pointer);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glWeightPointerOES");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glWeightPointerOES");
            return false;
        }
    }

    bool Gles::callGlColorPointerBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glColorPointerBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
            if (glColorPointerBounds != nullptr) {
                glColorPointerBounds(size, type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glColorPointerBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glColorPointerBounds");
            return false;
        }
    }

    bool Gles::callGlNormalPointerBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glNormalPointerBounds(%u, %" PRId32 ", %p, %" PRId32 ")", type, stride, pointer, count);
            if (glNormalPointerBounds != nullptr) {
                glNormalPointerBounds(type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glNormalPointerBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glNormalPointerBounds");
            return false;
        }
    }

    bool Gles::callGlTexCoordPointerBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glTexCoordPointerBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
            if (glTexCoordPointerBounds != nullptr) {
                glTexCoordPointerBounds(size, type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glTexCoordPointerBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glTexCoordPointerBounds");
            return false;
        }
    }

    bool Gles::callGlVertexPointerBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glVertexPointerBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
            if (glVertexPointerBounds != nullptr) {
                glVertexPointerBounds(size, type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glVertexPointerBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glVertexPointerBounds");
            return false;
        }
    }

    bool Gles::callGlPointSizePointerOESBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        if (stack->isValid()) {
            GAPID_INFO("glPointSizePointerOESBounds(%u, %" PRId32 ", %p, %" PRId32 ")", type, stride, pointer, count);
            if (glPointSizePointerOESBounds != nullptr) {
                glPointSizePointerOESBounds(type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glPointSizePointerOESBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glPointSizePointerOESBounds");
            return false;
        }
    }

    bool Gles::callGlMatrixIndexPointerOESBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glMatrixIndexPointerOESBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
            if (glMatrixIndexPointerOESBounds != nullptr) {
                glMatrixIndexPointerOESBounds(size, type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glMatrixIndexPointerOESBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glMatrixIndexPointerOESBounds");
            return false;
        }
    }

    bool Gles::callGlWeightPointerOESBounds(Stack* stack, bool pushReturn) {
        auto count = stack->pop<int32_t>();
        auto pointer = stack->pop<void*>();
        auto stride = stack->pop<int32_t>();
        auto type = stack->pop<GLenum>();
        auto size = stack->pop<int32_t>();
        if (stack->isValid()) {
            GAPID_INFO("glWeightPointerOESBounds(%" PRId32 ", %u, %" PRId32 ", %p, %" PRId32 ")", size, type, stride, pointer, count);
            if (glWeightPointerOESBounds != nullptr) {
                glWeightPointerOESBounds(size, type, stride, pointer, count);
            } else {
                GAPID_WARNING("Attempted to call unsupported function glWeightPointerOESBounds");
            }
            return true;
        } else {
            GAPID_WARNING("Error during calling function glWeightPointerOESBounds");
            return false;
        }
    }


}  // namespace gapir