cc/gapir/gles_gfx_api.cpp

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



#include "gles_gfx_api.h"

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

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

#define __STDC_FORMAT_MACROS
#include <inttypes.h>

namespace gapir {

const char* Gles::ID = "Gles";
uint8_t Gles::INDEX = 1;

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

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

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

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

bool Gles::callGlBlendBarrierKHR(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glBlendBarrierKHR()");
        if (mFunctionStubs.glBlendBarrierKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationSeparateiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFuncSeparateiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFunciEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColorMaskiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyImageSubDataEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDebugMessageCallbackKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDebugMessageControlKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDebugMessageInsertKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisableiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnableiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTextureEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetDebugMessageLogKHR != nullptr) {
            GLuint return_value = mFunctionStubs.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 (mFunctionStubs.glGetObjectLabelKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetObjectPtrLabelKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPointervKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterIivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterIuivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterIivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterIuivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsEnablediEXT != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glMinSampleShadingOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glObjectLabelKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glObjectPtrLabelKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPatchParameteriEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPopDebugGroupKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPrimitiveBoundingBoxEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPushDebugGroupKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterIivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterIuivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexBufferEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexBufferRangeEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterIivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterIuivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexStorage3DMultisampleOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBeginQuery != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteQueries != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndQuery != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenQueries != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryObjectuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsQuery != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glBindBuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindBufferBase != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindBufferRange != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBufferData != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBufferSubData != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyBufferSubData != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteBuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenBuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetBufferParameteri64v != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetBufferParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetBufferPointerv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsBuffer != nullptr) {
            GLboolean return_value = mFunctionStubs.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::callGlMapBuffer(Stack* stack, bool pushReturn) {
    auto access = stack->pop<GLenum>();
    auto target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMapBuffer(%u, %u)", target, access);
        if (mFunctionStubs.glMapBuffer != nullptr) {
            void* return_value = mFunctionStubs.glMapBuffer(target, access);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<void*>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMapBuffer");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMapBuffer");
        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 (mFunctionStubs.glMapBufferRange != nullptr) {
            void* return_value = mFunctionStubs.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 (mFunctionStubs.glUnmapBuffer != nullptr) {
            GLboolean return_value = mFunctionStubs.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::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 (mFunctionStubs.glFlushMappedBufferRange != nullptr) {
            mFunctionStubs.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::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 (mFunctionStubs.glDebugMessageCallback != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDebugMessageControl != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDebugMessageInsert != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetDebugMessageLog != nullptr) {
            GLuint return_value = mFunctionStubs.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 (mFunctionStubs.glGetObjectLabel != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetObjectPtrLabel != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPointerv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glObjectLabel != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glObjectPtrLabel != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPopDebugGroup != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPushDebugGroup != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArrays != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArraysIndirect != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArraysInstanced != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElements != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsBaseVertex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsIndirect != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstanced != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedBaseVertex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawRangeElements != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawRangeElementsBaseVertex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPatchParameteri != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPrimitiveBoundingBox != nullptr) {
            mFunctionStubs.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::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 (mFunctionStubs.eglGetConfigAttrib != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::callEglBindAPI(Stack* stack, bool pushReturn) {
    auto api = stack->pop<EGLenum>();
    if (stack->isValid()) {
        GAPID_INFO("eglBindAPI(%u)", api);
        if (mFunctionStubs.eglBindAPI != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglBindAPI(api);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglBindAPI");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglBindAPI");
        return false;
    }
}

bool Gles::callEglBindTexImage(Stack* stack, bool pushReturn) {
    auto buffer = stack->pop<int>();
    auto surface = stack->pop<void*>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglBindTexImage(%p, %p, %d)", display, surface, buffer);
        if (mFunctionStubs.eglBindTexImage != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglBindTexImage(display, surface, buffer);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglBindTexImage");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglBindTexImage");
        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 (mFunctionStubs.eglChooseConfig != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::callEglClientWaitSyncKHR(Stack* stack, bool pushReturn) {
    auto timeout = stack->pop<uint64_t>();
    auto sync_flags = stack->pop<int>();
    auto sync = stack->pop<void*>();
    auto dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglClientWaitSyncKHR(%p, %p, %d, %" PRIu64 ")", dpy, sync, sync_flags, timeout);
        if (mFunctionStubs.eglClientWaitSyncKHR != nullptr) {
            EGLint return_value = mFunctionStubs.eglClientWaitSyncKHR(dpy, sync, sync_flags, timeout);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLint>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglClientWaitSyncKHR");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglClientWaitSyncKHR");
        return false;
    }
}

bool Gles::callEglCopyBuffers(Stack* stack, bool pushReturn) {
    auto native_pixmap = stack->pop<void*>();
    auto surface = stack->pop<void*>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglCopyBuffers(%p, %p, %p)", display, surface, native_pixmap);
        if (mFunctionStubs.eglCopyBuffers != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglCopyBuffers(display, surface, native_pixmap);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglCopyBuffers");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglCopyBuffers");
        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 (mFunctionStubs.eglCreateContext != nullptr) {
            EGLContext return_value = mFunctionStubs.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::callEglCreatePbufferFromClientBuffer(Stack* stack, bool pushReturn) {
    auto attrib_list = stack->pop<EGLint*>();
    auto config = stack->pop<void*>();
    auto buffer = stack->pop<void*>();
    auto buftype = stack->pop<EGLenum>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglCreatePbufferFromClientBuffer(%p, %u, %p, %p, %p)", display, buftype, buffer, config, attrib_list);
        if (mFunctionStubs.eglCreatePbufferFromClientBuffer != nullptr) {
            EGLSurface return_value = mFunctionStubs.eglCreatePbufferFromClientBuffer(display, buftype, buffer, config, attrib_list);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<EGLSurface>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglCreatePbufferFromClientBuffer");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglCreatePbufferFromClientBuffer");
        return false;
    }
}

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

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

bool Gles::callEglCreateSyncKHR(Stack* stack, bool pushReturn) {
    auto attrib_list = stack->pop<EGLint*>();
    auto type = stack->pop<EGLenum>();
    auto dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglCreateSyncKHR(%p, %u, %p)", dpy, type, attrib_list);
        if (mFunctionStubs.eglCreateSyncKHR != nullptr) {
            EGLSyncKHR return_value = mFunctionStubs.eglCreateSyncKHR(dpy, type, attrib_list);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<EGLSyncKHR>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglCreateSyncKHR");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglCreateSyncKHR");
        return false;
    }
}

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

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

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

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

bool Gles::callEglGetConfigs(Stack* stack, bool pushReturn) {
    auto num_config = stack->pop<EGLint*>();
    auto config_size = stack->pop<int>();
    auto configs = stack->pop<EGLConfig*>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglGetConfigs(%p, %p, %d, %p)", display, configs, config_size, num_config);
        if (mFunctionStubs.eglGetConfigs != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglGetConfigs(display, 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 eglGetConfigs");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglGetConfigs");
        return false;
    }
}

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

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

bool Gles::callEglGetCurrentSurface(Stack* stack, bool pushReturn) {
    auto readdraw = stack->pop<int>();
    if (stack->isValid()) {
        GAPID_INFO("eglGetCurrentSurface(%d)", readdraw);
        if (mFunctionStubs.eglGetCurrentSurface != nullptr) {
            EGLSurface return_value = mFunctionStubs.eglGetCurrentSurface(readdraw);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<EGLSurface>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglGetCurrentSurface");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglGetCurrentSurface");
        return false;
    }
}

bool Gles::callEglGetDisplay(Stack* stack, bool pushReturn) {
    auto native_display = stack->pop<int>();
    if (stack->isValid()) {
        GAPID_INFO("eglGetDisplay(%d)", native_display);
        if (mFunctionStubs.eglGetDisplay != nullptr) {
            EGLDisplay return_value = mFunctionStubs.eglGetDisplay(native_display);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<EGLDisplay>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglGetDisplay");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglGetDisplay");
        return false;
    }
}

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

bool Gles::callEglGetSyncAttribKHR(Stack* stack, bool pushReturn) {
    auto value = stack->pop<EGLint*>();
    auto attribute = stack->pop<int>();
    auto sync = stack->pop<void*>();
    auto dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglGetSyncAttribKHR(%p, %p, %d, %p)", dpy, sync, attribute, value);
        if (mFunctionStubs.eglGetSyncAttribKHR != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglGetSyncAttribKHR(dpy, sync, attribute, value);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglGetSyncAttribKHR");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglGetSyncAttribKHR");
        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 (mFunctionStubs.eglInitialize != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::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 (mFunctionStubs.eglMakeCurrent != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::callEglQueryAPI(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("eglQueryAPI()");
        if (mFunctionStubs.eglQueryAPI != nullptr) {
            EGLenum return_value = mFunctionStubs.eglQueryAPI();
            GAPID_INFO("Returned: %u", return_value);
            if (pushReturn) {
                stack->push<EGLenum>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglQueryAPI");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglQueryAPI");
        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 (mFunctionStubs.eglQueryContext != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::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 (mFunctionStubs.eglQuerySurface != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::callEglQueryString(Stack* stack, bool pushReturn) {
    auto name = stack->pop<int>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglQueryString(%p, %d)", display, name);
        if (mFunctionStubs.eglQueryString != nullptr) {
            char* return_value = mFunctionStubs.eglQueryString(display, name);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<char*>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglQueryString");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglQueryString");
        return false;
    }
}

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

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

bool Gles::callEglSignalSyncKHR(Stack* stack, bool pushReturn) {
    auto mode = stack->pop<EGLenum>();
    auto sync = stack->pop<void*>();
    auto dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglSignalSyncKHR(%p, %p, %u)", dpy, sync, mode);
        if (mFunctionStubs.eglSignalSyncKHR != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglSignalSyncKHR(dpy, sync, mode);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglSignalSyncKHR");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglSignalSyncKHR");
        return false;
    }
}

bool Gles::callEglSurfaceAttrib(Stack* stack, bool pushReturn) {
    auto value = stack->pop<int>();
    auto attribute = stack->pop<int>();
    auto surface = stack->pop<void*>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglSurfaceAttrib(%p, %p, %d, %d)", display, surface, attribute, value);
        if (mFunctionStubs.eglSurfaceAttrib != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglSurfaceAttrib(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 eglSurfaceAttrib");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglSurfaceAttrib");
        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 (mFunctionStubs.eglSwapBuffers != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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 (mFunctionStubs.eglSwapBuffersWithDamageKHR != nullptr) {
            EGLBoolean return_value = mFunctionStubs.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::callEglSwapInterval(Stack* stack, bool pushReturn) {
    auto interval = stack->pop<int>();
    auto display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglSwapInterval(%p, %d)", display, interval);
        if (mFunctionStubs.eglSwapInterval != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglSwapInterval(display, interval);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglSwapInterval");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglSwapInterval");
        return false;
    }
}

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

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

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

bool Gles::callEglWaitNative(Stack* stack, bool pushReturn) {
    auto engine = stack->pop<int>();
    if (stack->isValid()) {
        GAPID_INFO("eglWaitNative(%d)", engine);
        if (mFunctionStubs.eglWaitNative != nullptr) {
            EGLBoolean return_value = mFunctionStubs.eglWaitNative(engine);
            GAPID_INFO("Returned: %d", return_value);
            if (pushReturn) {
                stack->push<EGLBoolean>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglWaitNative");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglWaitNative");
        return false;
    }
}

bool Gles::callEglCreateImageKHR(Stack* stack, bool pushReturn) {
    auto attrib_list = stack->pop<EGLint*>();
    auto buffer = stack->pop<void*>();
    auto target = stack->pop<EGLenum>();
    auto ctx = stack->pop<void*>();
    auto dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglCreateImageKHR(%p, %p, %u, %p, %p)", dpy, ctx, target, buffer, attrib_list);
        if (mFunctionStubs.eglCreateImageKHR != nullptr) {
            EGLImageKHR return_value = mFunctionStubs.eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<EGLImageKHR>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglCreateImageKHR");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglCreateImageKHR");
        return false;
    }
}

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

bool Gles::callEglCreateNativeClientBufferANDROID(Stack* stack, bool pushReturn) {
    auto attrib_list = stack->pop<EGLint*>();
    if (stack->isValid()) {
        GAPID_INFO("eglCreateNativeClientBufferANDROID(%p)", attrib_list);
        if (mFunctionStubs.eglCreateNativeClientBufferANDROID != nullptr) {
            EGLClientBuffer return_value = mFunctionStubs.eglCreateNativeClientBufferANDROID(attrib_list);
            GAPID_INFO("Returned: %p", return_value);
            if (pushReturn) {
                stack->push<EGLClientBuffer>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglCreateNativeClientBufferANDROID");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglCreateNativeClientBufferANDROID");
        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 (mFunctionStubs.glActiveShaderProgramEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glAlphaFuncQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glApplyFramebufferAttachmentCMAAINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBeginConditionalRenderNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBeginPerfMonitorAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBeginPerfQueryINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBeginQueryEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindFragDataLocationEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindFragDataLocationIndexedEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindProgramPipelineEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindVertexArrayOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendBarrierNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationSeparateiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFuncSeparateiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFunciOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendParameteriNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlitFramebufferANGLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlitFramebufferNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBufferStorageEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClientWaitSyncAPPLE != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glColorMaskiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompressedTexImage3DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompressedTexSubImage3DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyBufferSubDataNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyImageSubDataOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyPathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyTexSubImage3DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyTextureLevelsAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverFillPathInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverFillPathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverStrokePathInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverStrokePathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverageMaskNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverageModulationNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverageModulationTableNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCoverageOperationNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCreatePerfQueryINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCreateShaderProgramvEXT != nullptr) {
            GLuint return_value = mFunctionStubs.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 (mFunctionStubs.glDeleteFencesNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeletePathsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeletePerfMonitorsAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeletePerfQueryINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteProgramPipelinesEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteQueriesEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteSyncAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteVertexArraysOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthRangeArrayfvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthRangeIndexedfNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisableDriverControlQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisableiNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisableiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDiscardFramebufferEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArraysInstancedANGLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArraysInstancedBaseInstanceEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArraysInstancedEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawArraysInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawBuffersEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawBuffersIndexedEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawBuffersNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsBaseVertexEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsBaseVertexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedANGLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedBaseInstanceEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedBaseVertexBaseInstanceEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedBaseVertexEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedBaseVertexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawElementsInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawRangeElementsBaseVertexEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawRangeElementsBaseVertexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEGLImageTargetRenderbufferStorageOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEGLImageTargetTexture2DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnableDriverControlQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnableiNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnableiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndConditionalRenderNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndPerfMonitorAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndPerfQueryINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndQueryEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndTilingQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetBufferPointervQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetBuffersQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetFramebuffersQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetProgramBinarySourceQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetProgramsQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetRenderbuffersQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetShadersQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetTexLevelParameterivQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetTexSubImageQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtGetTexturesQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glExtIsProgramBinaryQCOM != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glExtTexObjectStateOverrideiQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFenceSyncAPPLE != nullptr) {
            GLsync return_value = mFunctionStubs.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 (mFunctionStubs.glFinishFenceNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFlushMappedBufferRangeEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFragmentCoverageColorNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferSampleLocationsfvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTexture2DMultisampleEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTexture2DMultisampleIMG != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTexture3DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTextureMultiviewOVR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTextureOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenFencesNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenPathsNV != nullptr) {
            GLuint return_value = mFunctionStubs.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 (mFunctionStubs.glGenPerfMonitorsAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenProgramPipelinesEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenQueriesEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenVertexArraysOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetBufferPointervOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetCoverageModulationTableNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetDriverControlStringQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetDriverControlsQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFenceivNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFirstPerfQueryIdINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFloati_vNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFragDataIndexEXT != nullptr) {
            GLint return_value = mFunctionStubs.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 (mFunctionStubs.glGetGraphicsResetStatusEXT != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glGetGraphicsResetStatusKHR != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glGetImageHandleNV != nullptr) {
            GLuint64 return_value = mFunctionStubs.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 (mFunctionStubs.glGetInteger64vAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetIntegeri_vEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetInternalformatSampleivNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetNextPerfQueryIdINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetObjectLabelEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathCommandsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathCoordsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathDashArrayNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathLengthNV != nullptr) {
            GLfloat return_value = mFunctionStubs.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 (mFunctionStubs.glGetPathMetricRangeNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathMetricsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathParameterfvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathParameterivNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPathSpacingNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfCounterInfoINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfMonitorCounterDataAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfMonitorCounterInfoAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfMonitorCounterStringAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfMonitorCountersAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfMonitorGroupStringAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfMonitorGroupsAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfQueryDataINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfQueryIdByNameINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetPerfQueryInfoINTEL != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramBinaryOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramPipelineInfoLogEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramPipelineivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramResourceLocationIndexEXT != nullptr) {
            GLint return_value = mFunctionStubs.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 (mFunctionStubs.glGetProgramResourcefvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryObjecti64vEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryObjectivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryObjectui64vEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryObjectuivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterIivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterIuivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSyncivAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterIivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterIuivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTextureHandleNV != nullptr) {
            GLuint64 return_value = mFunctionStubs.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 (mFunctionStubs.glGetTextureSamplerHandleNV != nullptr) {
            GLuint64 return_value = mFunctionStubs.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 (mFunctionStubs.glGetTranslatedShaderSourceANGLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformfvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformfvKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformivKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformuivKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glInsertEventMarkerEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glInterpolatePathsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsEnablediNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsEnablediOES != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsFenceNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsImageHandleResidentNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsPathNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsPointInFillPathNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsPointInStrokePathNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsProgramPipelineEXT != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsQueryEXT != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsSyncAPPLE != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsTextureHandleResidentNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsVertexArrayOES != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glLabelObjectEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMakeImageHandleNonResidentNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMakeImageHandleResidentNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMakeTextureHandleNonResidentNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMakeTextureHandleResidentNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMapBufferOES != nullptr) {
            void* return_value = mFunctionStubs.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 (mFunctionStubs.glMapBufferRangeEXT != nullptr) {
            void* return_value = mFunctionStubs.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 (mFunctionStubs.glMatrixLoad3x2fNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixLoad3x3fNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixLoadTranspose3x3fNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixMult3x2fNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixMult3x3fNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixMultTranspose3x3fNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiDrawArraysEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiDrawArraysIndirectEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiDrawElementsBaseVertexEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiDrawElementsBaseVertexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiDrawElementsEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiDrawElementsIndirectEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glNamedFramebufferSampleLocationsfvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPatchParameteriOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathCommandsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathCoordsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathCoverDepthFuncNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathDashArrayNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathGlyphIndexArrayNV != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glPathGlyphIndexRangeNV != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glPathGlyphRangeNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathGlyphsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathMemoryGlyphIndexArrayNV != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glPathParameterfNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathParameterfvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathParameteriNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathParameterivNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathStencilDepthOffsetNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathStencilFuncNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathStringNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathSubCommandsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPathSubCoordsNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointAlongPathNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glPolygonModeNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPopGroupMarkerEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPrimitiveBoundingBoxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramBinaryOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramParameteriEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramPathFragmentInputGenNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1fEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1iEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1ivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1uiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1uivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2fEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2iEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2ivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2uiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2uivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3fEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3iEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3ivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3uiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3uivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4fEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4iEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4ivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4uiEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4uivEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformHandleui64NV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformHandleui64vNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix2fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix2x3fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix2x4fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix3fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix3x2fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix3x4fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix4fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix4x2fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix4x3fvEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPushGroupMarkerEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glQueryCounterEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRasterSamplesEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReadBufferIndexedEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReadBufferNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReadnPixelsEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReadnPixelsKHR != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageMultisampleANGLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageMultisampleAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageMultisampleEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageMultisampleIMG != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageMultisampleNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glResolveDepthValuesNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glResolveMultisampleFramebufferAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterIivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterIuivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScissorArrayvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScissorIndexedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScissorIndexedvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSelectPerfMonitorCountersAMD != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSetFenceNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStartTilingQCOM != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilFillPathInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilFillPathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilStrokePathInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilStrokePathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilThenCoverFillPathInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilThenCoverFillPathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilThenCoverStrokePathInstancedNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilThenCoverStrokePathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSubpixelPrecisionBiasNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTestFenceNV != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glTexBufferOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexBufferRangeOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexImage3DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexPageCommitmentEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterIivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterIuivOES != nullptr) {
            mFunctionStubs.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 internalformat = 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, internalformat, width);
        if (mFunctionStubs.glTexStorage1DEXT != nullptr) {
            mFunctionStubs.glTexStorage1DEXT(target, levels, internalformat, 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 internalformat = 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, internalformat, width, height);
        if (mFunctionStubs.glTexStorage2DEXT != nullptr) {
            mFunctionStubs.glTexStorage2DEXT(target, levels, internalformat, 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 internalformat = 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, internalformat, width, height, depth);
        if (mFunctionStubs.glTexStorage3DEXT != nullptr) {
            mFunctionStubs.glTexStorage3DEXT(target, levels, internalformat, 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 (mFunctionStubs.glTexSubImage3DOES != nullptr) {
            mFunctionStubs.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 internalformat = 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, internalformat, width);
        if (mFunctionStubs.glTextureStorage1DEXT != nullptr) {
            mFunctionStubs.glTextureStorage1DEXT(texture, target, levels, internalformat, 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 internalformat = 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, internalformat, width, height);
        if (mFunctionStubs.glTextureStorage2DEXT != nullptr) {
            mFunctionStubs.glTextureStorage2DEXT(texture, target, levels, internalformat, 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 internalformat = 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, internalformat, width, height, depth);
        if (mFunctionStubs.glTextureStorage3DEXT != nullptr) {
            mFunctionStubs.glTextureStorage3DEXT(texture, target, levels, internalformat, 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 (mFunctionStubs.glTextureViewEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTextureViewOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTransformPathNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformHandleui64NV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformHandleui64vNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix2x3fvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix2x4fvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix3x2fvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix3x4fvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix4x2fvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix4x3fvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUnmapBufferOES != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glUseProgramStagesEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glValidateProgramPipelineEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribDivisorANGLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribDivisorEXT != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribDivisorNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glViewportArrayvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glViewportIndexedfNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glViewportIndexedfvNV != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glWaitSyncAPPLE != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glWeightPathsNV != nullptr) {
            mFunctionStubs.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::callGlClearPixelLocalStorageuiEXT(Stack* stack, bool pushReturn) {
    auto values = stack->pop<GLuint*>();
    auto n = stack->pop<int32_t>();
    auto offset = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glClearPixelLocalStorageuiEXT(%" PRId32 ", %" PRId32 ", %p)", offset, n, values);
        if (mFunctionStubs.glClearPixelLocalStorageuiEXT != nullptr) {
            mFunctionStubs.glClearPixelLocalStorageuiEXT(offset, n, values);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearPixelLocalStorageuiEXT");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearPixelLocalStorageuiEXT");
        return false;
    }
}

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

bool Gles::callGlClearTexSubImageEXT(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 texture = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glClearTexSubImageEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
        if (mFunctionStubs.glClearTexSubImageEXT != nullptr) {
            mFunctionStubs.glClearTexSubImageEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearTexSubImageEXT");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearTexSubImageEXT");
        return false;
    }
}

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

bool Gles::callGlDepthRangeArrayfvOES(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("glDepthRangeArrayfvOES(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
        if (mFunctionStubs.glDepthRangeArrayfvOES != nullptr) {
            mFunctionStubs.glDepthRangeArrayfvOES(first, count, v);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthRangeArrayfvOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthRangeArrayfvOES");
        return false;
    }
}

bool Gles::callGlDepthRangeIndexedfOES(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("glDepthRangeIndexedfOES(%" PRIu32 ", %f, %f)", index, n, f);
        if (mFunctionStubs.glDepthRangeIndexedfOES != nullptr) {
            mFunctionStubs.glDepthRangeIndexedfOES(index, n, f);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthRangeIndexedfOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthRangeIndexedfOES");
        return false;
    }
}

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

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

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

bool Gles::callGlFramebufferTexture2DDownsampleIMG(Stack* stack, bool pushReturn) {
    auto yscale = stack->pop<int32_t>();
    auto xscale = 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("glFramebufferTexture2DDownsampleIMG(%u, %u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, textarget, texture, level, xscale, yscale);
        if (mFunctionStubs.glFramebufferTexture2DDownsampleIMG != nullptr) {
            mFunctionStubs.glFramebufferTexture2DDownsampleIMG(target, attachment, textarget, texture, level, xscale, yscale);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFramebufferTexture2DDownsampleIMG");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFramebufferTexture2DDownsampleIMG");
        return false;
    }
}

bool Gles::callGlFramebufferTextureLayerDownsampleIMG(Stack* stack, bool pushReturn) {
    auto yscale = stack->pop<int32_t>();
    auto xscale = stack->pop<int32_t>();
    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("glFramebufferTextureLayerDownsampleIMG(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, layer, xscale, yscale);
        if (mFunctionStubs.glFramebufferTextureLayerDownsampleIMG != nullptr) {
            mFunctionStubs.glFramebufferTextureLayerDownsampleIMG(target, attachment, texture, level, layer, xscale, yscale);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFramebufferTextureLayerDownsampleIMG");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFramebufferTextureLayerDownsampleIMG");
        return false;
    }
}

bool Gles::callGlFramebufferTextureMultisampleMultiviewOVR(Stack* stack, bool pushReturn) {
    auto numViews = stack->pop<int32_t>();
    auto baseViewIndex = stack->pop<int32_t>();
    auto samples = 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("glFramebufferTextureMultisampleMultiviewOVR(%u, %u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", target, attachment, texture, level, samples, baseViewIndex, numViews);
        if (mFunctionStubs.glFramebufferTextureMultisampleMultiviewOVR != nullptr) {
            mFunctionStubs.glFramebufferTextureMultisampleMultiviewOVR(target, attachment, texture, level, samples, baseViewIndex, numViews);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFramebufferTextureMultisampleMultiviewOVR");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFramebufferTextureMultisampleMultiviewOVR");
        return false;
    }
}

bool Gles::callGlGetFloatiVOES(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_vOES(%u, %" PRIu32 ", %p)", target, index, data);
        if (mFunctionStubs.glGetFloati_vOES != nullptr) {
            mFunctionStubs.glGetFloati_vOES(target, index, data);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFloati_vOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFloati_vOES");
        return false;
    }
}

bool Gles::callGlGetFramebufferPixelLocalStorageSizeEXT(Stack* stack, bool pushReturn) {
    auto target = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFramebufferPixelLocalStorageSizeEXT(%" PRIu32 ")", target);
        if (mFunctionStubs.glGetFramebufferPixelLocalStorageSizeEXT != nullptr) {
            GLsizei return_value = mFunctionStubs.glGetFramebufferPixelLocalStorageSizeEXT(target);
            GAPID_INFO("Returned: %" PRId32 "", return_value);
            if (pushReturn) {
                stack->push<GLsizei>(return_value);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFramebufferPixelLocalStorageSizeEXT");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFramebufferPixelLocalStorageSizeEXT");
        return false;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

bool Gles::callGlProgramUniform3i64NV(Stack* stack, bool pushReturn) {
    auto z = stack->pop<int64_t>();
    auto y = stack->pop<int64_t>();
    auto x = stack->pop<int64_t>();
    auto location = stack->pop<int32_t>();
    auto program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3i64NV(%" PRIu32 ", %" PRId32 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z);
        if (mFunctionStubs.glProgramUniform3i64NV != nullptr) {
            mFunctionStubs.glProgramUniform3i64NV(program, location, x, y, z);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3i64NV");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3i64NV");
        return false;
    }
}

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

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

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

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

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

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

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

bool Gles::callGlProgramUniformHandleui64IMG(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("glProgramUniformHandleui64IMG(%" PRIu32 ", %" PRId32 ", %" PRIu64 ")", program, location, value);
        if (mFunctionStubs.glProgramUniformHandleui64IMG != nullptr) {
            mFunctionStubs.glProgramUniformHandleui64IMG(program, location, value);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformHandleui64IMG");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformHandleui64IMG");
        return false;
    }
}

bool Gles::callGlProgramUniformHandleui64vIMG(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("glProgramUniformHandleui64vIMG(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)", program, location, count, values);
        if (mFunctionStubs.glProgramUniformHandleui64vIMG != nullptr) {
            mFunctionStubs.glProgramUniformHandleui64vIMG(program, location, count, values);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformHandleui64vIMG");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformHandleui64vIMG");
        return false;
    }
}

bool Gles::callGlScissorArrayvOES(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("glScissorArrayvOES(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
        if (mFunctionStubs.glScissorArrayvOES != nullptr) {
            mFunctionStubs.glScissorArrayvOES(first, count, v);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glScissorArrayvOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glScissorArrayvOES");
        return false;
    }
}

bool Gles::callGlScissorIndexedOES(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("glScissorIndexedOES(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")", index, left, bottom, width, height);
        if (mFunctionStubs.glScissorIndexedOES != nullptr) {
            mFunctionStubs.glScissorIndexedOES(index, left, bottom, width, height);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glScissorIndexedOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glScissorIndexedOES");
        return false;
    }
}

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

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

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

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

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

bool Gles::callGlUniform2i64NV(Stack* stack, bool pushReturn) {
    auto y = stack->pop<int64_t>();
    auto x = stack->pop<int64_t>();
    auto location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2i64NV(%" PRId32 ", %" PRId64 ", %" PRId64 ")", location, x, y);
        if (mFunctionStubs.glUniform2i64NV != nullptr) {
            mFunctionStubs.glUniform2i64NV(location, x, y);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2i64NV");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2i64NV");
        return false;
    }
}

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

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

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

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

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

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

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

bool Gles::callGlUniform4i64NV(Stack* stack, bool pushReturn) {
    auto w = stack->pop<int64_t>();
    auto z = stack->pop<int64_t>();
    auto y = stack->pop<int64_t>();
    auto x = stack->pop<int64_t>();
    auto location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4i64NV(%" PRId32 ", %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z, w);
        if (mFunctionStubs.glUniform4i64NV != nullptr) {
            mFunctionStubs.glUniform4i64NV(location, x, y, z, w);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4i64NV");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4i64NV");
        return false;
    }
}

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

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

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

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

bool Gles::callGlUniformHandleui64vIMG(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("glUniformHandleui64vIMG(%" PRId32 ", %" PRId32 ", %p)", location, count, value);
        if (mFunctionStubs.glUniformHandleui64vIMG != nullptr) {
            mFunctionStubs.glUniformHandleui64vIMG(location, count, value);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformHandleui64vIMG");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformHandleui64vIMG");
        return false;
    }
}

bool Gles::callGlViewportArrayvOES(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("glViewportArrayvOES(%" PRIu32 ", %" PRId32 ", %p)", first, count, v);
        if (mFunctionStubs.glViewportArrayvOES != nullptr) {
            mFunctionStubs.glViewportArrayvOES(first, count, v);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glViewportArrayvOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glViewportArrayvOES");
        return false;
    }
}

bool Gles::callGlViewportIndexedfOES(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("glViewportIndexedfOES(%" PRIu32 ", %f, %f, %f, %f)", index, x, y, w, h);
        if (mFunctionStubs.glViewportIndexedfOES != nullptr) {
            mFunctionStubs.glViewportIndexedfOES(index, x, y, w, h);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glViewportIndexedfOES");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glViewportIndexedfOES");
        return false;
    }
}

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

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

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

bool Gles::callGlBlendBarrier(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glBlendBarrier()");
        if (mFunctionStubs.glBlendBarrier != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendColor != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquation != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationSeparate != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationSeparatei != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationi != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFunc != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFuncSeparate != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFuncSeparatei != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFunci != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthFunc != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSampleCoverage != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSampleMaski != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScissor != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilFunc != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilFuncSeparate != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilOp != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilOpSeparate != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindFramebuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindRenderbuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlitFramebuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCheckFramebufferStatus != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glClear != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearBufferfi != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearBufferfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearBufferiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearBufferuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearColor != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearDepthf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearStencil != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColorMask != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColorMaski != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteFramebuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteRenderbuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthMask != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawBuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferParameteri != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferRenderbuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTexture != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTexture2D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTextureLayer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenFramebuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenRenderbuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFramebufferAttachmentParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFramebufferParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetRenderbufferParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glInvalidateFramebuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glInvalidateSubFramebuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsFramebuffer != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsRenderbuffer != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glReadBuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReadPixels != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReadnPixels != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorage != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageMultisample != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilMask != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glStencilMaskSeparate != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisable != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisablei != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnable != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnablei != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFinish != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFlush != nullptr) {
            mFunctionStubs.glFlush();
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFlush");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFlush");
        return false;
    }
}

bool Gles::callGlGetError(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glGetError()");
        if (mFunctionStubs.glGetError != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glGetGraphicsResetStatus != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glHint != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glActiveShaderProgram != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glAttachShader != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindAttribLocation != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindProgramPipeline != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompileShader != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCreateProgram != nullptr) {
            ProgramId return_value = mFunctionStubs.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 (mFunctionStubs.glCreateShader != nullptr) {
            ShaderId return_value = mFunctionStubs.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 (mFunctionStubs.glCreateShaderProgramv != nullptr) {
            ProgramId return_value = mFunctionStubs.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 (mFunctionStubs.glDeleteProgram != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteProgramPipelines != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteShader != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDetachShader != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDispatchCompute != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDispatchComputeIndirect != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenProgramPipelines != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetActiveAttrib != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetActiveUniform != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetActiveUniformBlockName != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetActiveUniformBlockiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetActiveUniformsiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetAttachedShaders != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetAttribLocation != nullptr) {
            GLint return_value = mFunctionStubs.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 (mFunctionStubs.glGetFragDataLocation != nullptr) {
            GLint return_value = mFunctionStubs.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 (mFunctionStubs.glGetProgramBinary != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramInfoLog != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramInterfaceiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramPipelineInfoLog != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramPipelineiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramResourceIndex != nullptr) {
            GLuint return_value = mFunctionStubs.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 (mFunctionStubs.glGetProgramResourceLocation != nullptr) {
            GLint return_value = mFunctionStubs.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 (mFunctionStubs.glGetProgramResourceName != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramResourceiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetProgramiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetShaderInfoLog != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetShaderPrecisionFormat != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetShaderSource != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetShaderiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetUniformBlockIndex != nullptr) {
            UniformBlockId return_value = mFunctionStubs.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 (mFunctionStubs.glGetUniformIndices != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetUniformLocation != nullptr) {
            UniformLocation return_value = mFunctionStubs.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 (mFunctionStubs.glGetUniformfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetUniformiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetUniformuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetnUniformuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsProgram != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsProgramPipeline != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsShader != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glLinkProgram != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMemoryBarrier != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMemoryBarrierByRegion != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramBinary != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramParameteri != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform1uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform2uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform3uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniform4uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix2x3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix2x4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix3x2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix3x4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix4x2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glProgramUniformMatrix4x3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glReleaseShaderCompiler != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glShaderBinary != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glShaderSource != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform1f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform1fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform1i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform1iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform1ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform1uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform2f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform2i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform2iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform2ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform2uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform3f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform3i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform3iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform3ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform3uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform4f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform4i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform4iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform4ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniform4uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformBlockBinding != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix2x3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix2x4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix3x2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix3x4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix4x2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUniformMatrix4x3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUseProgram != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glUseProgramStages != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glValidateProgram != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glValidateProgramPipeline != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCullFace != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthRangef != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFrontFace != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetMultisamplefv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLineWidth != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMinSampleShading != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPolygonOffset != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glViewport != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetBooleani_v != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetBooleanv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFloatv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetInteger64i_v != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetInteger64v != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetIntegeri_v != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetIntegerv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetInternalformativ != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetString != nullptr) {
            GLubyte* return_value = mFunctionStubs.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 (mFunctionStubs.glGetStringi != nullptr) {
            GLubyte* return_value = mFunctionStubs.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 (mFunctionStubs.glIsEnabled != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsEnabledi != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glClientWaitSync != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glDeleteSync != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFenceSync != nullptr) {
            GLsync return_value = mFunctionStubs.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 (mFunctionStubs.glGetSynciv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsSync != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glWaitSync != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glActiveTexture != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindImageTexture != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindSampler != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindTexture != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompressedTexImage2D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompressedTexImage3D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompressedTexSubImage2D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCompressedTexSubImage3D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyImageSubData != nullptr) {
            mFunctionStubs.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 internalformat = 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, internalformat, x, y, width, height, border);
        if (mFunctionStubs.glCopyTexImage2D != nullptr) {
            mFunctionStubs.glCopyTexImage2D(target, level, internalformat, 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 (mFunctionStubs.glCopyTexSubImage2D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCopyTexSubImage3D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteSamplers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteTextures != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenSamplers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenTextures != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenerateMipmap != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterIiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterIuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameterfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetSamplerParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexLevelParameterfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexLevelParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterIiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterIuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsSampler != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsTexture != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glPixelStorei != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterIiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterIuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameterfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameteri != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSamplerParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexBuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexBufferRange != nullptr) {
            mFunctionStubs.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 internalformat = 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, internalformat, width, height, border, format, type, data);
        if (mFunctionStubs.glTexImage2D != nullptr) {
            mFunctionStubs.glTexImage2D(target, level, internalformat, 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 (mFunctionStubs.glTexImage3D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterIiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterIuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameteri != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameteriv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexStorage2D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexStorage2DMultisample != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexStorage3D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexStorage3DMultisample != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexSubImage2D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexSubImage3D != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBeginTransformFeedback != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindTransformFeedback != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteTransformFeedbacks != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEndTransformFeedback != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenTransformFeedbacks != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTransformFeedbackVarying != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsTransformFeedback != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glPauseTransformFeedback != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glResumeTransformFeedback != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTransformFeedbackVaryings != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindVertexArray != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindVertexBuffer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteVertexArrays != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisableVertexAttribArray != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnableVertexAttribArray != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenVertexArrays != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetVertexAttribIiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetVertexAttribIuiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetVertexAttribPointerv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetVertexAttribfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetVertexAttribiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsVertexArray != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glVertexAttrib1f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib1fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib2f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib2fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib3f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib3fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib4f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttrib4fv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribBinding != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribDivisor != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribFormat != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribI4i != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribI4iv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribI4ui != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribI4uiv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribIFormat != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribIPointer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexAttribPointer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexBindingDivisor != nullptr) {
            mFunctionStubs.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::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 (mFunctionStubs.glXCreateContext != nullptr) {
            GLXContext return_value = mFunctionStubs.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 (mFunctionStubs.glXCreateNewContext != nullptr) {
            GLXContext return_value = mFunctionStubs.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 (mFunctionStubs.glXMakeContextCurrent != nullptr) {
            Bool return_value = mFunctionStubs.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 (mFunctionStubs.glXMakeCurrent != nullptr) {
            Bool return_value = mFunctionStubs.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 (mFunctionStubs.glXSwapBuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glXQueryDrawable != nullptr) {
            int return_value = mFunctionStubs.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 (mFunctionStubs.wglCreateContext != nullptr) {
            HGLRC return_value = mFunctionStubs.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 (mFunctionStubs.wglCreateContextAttribsARB != nullptr) {
            HGLRC return_value = mFunctionStubs.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 (mFunctionStubs.wglMakeCurrent != nullptr) {
            BOOL return_value = mFunctionStubs.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 (mFunctionStubs.wglSwapBuffers != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.CGLCreateContext != nullptr) {
            CGLError return_value = mFunctionStubs.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 (mFunctionStubs.CGLSetCurrentContext != nullptr) {
            CGLError return_value = mFunctionStubs.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 (mFunctionStubs.CGLGetSurface != nullptr) {
            int return_value = mFunctionStubs.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 (mFunctionStubs.CGSGetSurfaceBounds != nullptr) {
            int return_value = mFunctionStubs.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 (mFunctionStubs.CGLFlushDrawable != nullptr) {
            CGLError return_value = mFunctionStubs.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 (mFunctionStubs.glGetQueryObjecti64v != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetQueryObjectui64v != nullptr) {
            mFunctionStubs.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::callGlTexStorage1D(Stack* stack, bool pushReturn) {
    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("glTexStorage1D(%u, %" PRId32 ", %u, %" PRId32 ")", target, levels, internalformat, width);
        if (mFunctionStubs.glTexStorage1D != nullptr) {
            mFunctionStubs.glTexStorage1D(target, levels, internalformat, width);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexStorage1D");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexStorage1D");
        return false;
    }
}

bool Gles::callGlBindFragDataLocation(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("glBindFragDataLocation(%" PRIu32 ", %" PRIu32 ", %s)", program, color, name);
        if (mFunctionStubs.glBindFragDataLocation != nullptr) {
            mFunctionStubs.glBindFragDataLocation(program, color, name);
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindFragDataLocation");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindFragDataLocation");
        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 (mFunctionStubs.glAlphaFunc != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glAlphaFuncx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glAlphaFuncxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindFramebufferOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBindRenderbufferOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendEquationSeparateOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glBlendFuncSeparateOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCheckFramebufferStatusOES != nullptr) {
            GLenum return_value = mFunctionStubs.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 (mFunctionStubs.glClearColorx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearColorxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearDepthfOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearDepthx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClearDepthxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClientActiveTexture != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClipPlanef != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClipPlanefIMG != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClipPlanefOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClipPlanex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClipPlanexIMG != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glClipPlanexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColor4f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColor4ub != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColor4x != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColor4xOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColorPointer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glCurrentPaletteMatrixOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteFramebuffersOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDeleteRenderbuffersOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthRangefOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthRangex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDepthRangexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDisableClientState != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexfOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexfvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexiOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexsOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexsvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glDrawTexxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glEnableClientState != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFogf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFogfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFogx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFogxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFogxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFogxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferRenderbufferOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFramebufferTexture2DOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFrustumf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFrustumfOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFrustumx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glFrustumxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenFramebuffersOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenRenderbuffersOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGenerateMipmapOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetClipPlanef != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetClipPlanefOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetClipPlanex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetClipPlanexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFixedv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFixedvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetFramebufferAttachmentParameterivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetLightfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetLightxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetLightxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetMaterialfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetMaterialxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetMaterialxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetRenderbufferParameterivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexEnvfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexEnviv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexEnvxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexEnvxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexGenfvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexGenivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexGenxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glGetTexParameterxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glIsFramebufferOES != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glIsRenderbufferOES != nullptr) {
            GLboolean return_value = mFunctionStubs.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 (mFunctionStubs.glLightModelf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightModelfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightModelx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightModelxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightModelxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightModelxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLightxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLineWidthx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLineWidthxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLoadIdentity != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLoadMatrixf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLoadMatrixx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLoadMatrixxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLoadPaletteFromModelViewMatrixOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glLogicOp != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMaterialf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMaterialfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMaterialx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMaterialxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMaterialxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMaterialxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixIndexPointerOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixMode != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultMatrixf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultMatrixx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultMatrixxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiTexCoord4f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiTexCoord4x != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMultiTexCoord4xOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glNormal3f != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glNormal3x != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glNormal3xOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glNormalPointer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glOrthof != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glOrthofOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glOrthox != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glOrthoxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointParameterf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointParameterfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointParameterx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointParameterxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointParameterxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointParameterxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointSize != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointSizePointerOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointSizex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointSizexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPolygonOffsetx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPolygonOffsetxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPopMatrix != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPushMatrix != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glQueryMatrixxOES != nullptr) {
            GLbitfield return_value = mFunctionStubs.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 (mFunctionStubs.glRenderbufferStorageOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRotatef != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRotatex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glRotatexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSampleCoveragex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glSampleCoveragexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScalef != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScalex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glScalexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glShadeModel != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexCoordPointer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvf != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvfv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvi != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnviv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexEnvxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexGenfOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexGenfvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexGeniOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexGenivOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexGenxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexGenxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterx != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterxOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterxv != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexParameterxvOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTranslatef != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTranslatex != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTranslatexOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexPointer != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glWeightPointerOES != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glColorPointerBounds != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glNormalPointerBounds != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glTexCoordPointerBounds != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glVertexPointerBounds != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glPointSizePointerOESBounds != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glMatrixIndexPointerOESBounds != nullptr) {
            mFunctionStubs.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 (mFunctionStubs.glWeightPointerOESBounds != nullptr) {
            mFunctionStubs.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