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

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

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

#define __STDC_FORMAT_MACROS
#include <inttypes.h>

namespace gapir {
namespace gfxapi {
namespace {

bool callGlBlendBarrierKHR(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glBlendBarrierKHR()\n");
        if (glBlendBarrierKHR != nullptr) {
            glBlendBarrierKHR();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendBarrierKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendBarrierKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendBarrierKHR\n");
        return false;
    }
}

bool callGlBlendEquationSeparateiEXT(Stack* stack, bool pushReturn) {
    GLenum modeAlpha = stack->pop<GLenum>();
    GLenum modeRGB = stack->pop<GLenum>();
    uint32_t buf = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendEquationSeparateiEXT(%" PRIu32 ", %u, %u)\n", buf, modeRGB, modeAlpha);
        if (glBlendEquationSeparateiEXT != nullptr) {
            glBlendEquationSeparateiEXT(buf, modeRGB, modeAlpha);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendEquationSeparateiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparateiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendEquationSeparateiEXT\n");
        return false;
    }
}

bool callGlBlendEquationiEXT(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    uint32_t buf = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendEquationiEXT(%" PRIu32 ", %u)\n", buf, mode);
        if (glBlendEquationiEXT != nullptr) {
            glBlendEquationiEXT(buf, mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendEquationiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendEquationiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendEquationiEXT\n");
        return false;
    }
}

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

bool callGlBlendFunciEXT(Stack* stack, bool pushReturn) {
    GLenum dst = stack->pop<GLenum>();
    GLenum src = stack->pop<GLenum>();
    uint32_t buf = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendFunciEXT(%" PRIu32 ", %u, %u)\n", buf, src, dst);
        if (glBlendFunciEXT != nullptr) {
            glBlendFunciEXT(buf, src, dst);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendFunciEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendFunciEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendFunciEXT\n");
        return false;
    }
}

bool callGlColorMaskiEXT(Stack* stack, bool pushReturn) {
    uint8_t a = stack->pop<uint8_t>();
    uint8_t b = stack->pop<uint8_t>();
    uint8_t g = stack->pop<uint8_t>();
    uint8_t r = stack->pop<uint8_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glColorMaskiEXT(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")\n",
                   index, r, g, b, a);
        if (glColorMaskiEXT != nullptr) {
            glColorMaskiEXT(index, r, g, b, a);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glColorMaskiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glColorMaskiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glColorMaskiEXT\n");
        return false;
    }
}

bool callGlCopyImageSubDataEXT(Stack* stack, bool pushReturn) {
    int32_t srcDepth = stack->pop<int32_t>();
    int32_t srcHeight = stack->pop<int32_t>();
    int32_t srcWidth = stack->pop<int32_t>();
    int32_t dstZ = stack->pop<int32_t>();
    int32_t dstY = stack->pop<int32_t>();
    int32_t dstX = stack->pop<int32_t>();
    int32_t dstLevel = stack->pop<int32_t>();
    GLenum dstTarget = stack->pop<GLenum>();
    uint32_t dstName = stack->pop<uint32_t>();
    int32_t srcZ = stack->pop<int32_t>();
    int32_t srcY = stack->pop<int32_t>();
    int32_t srcX = stack->pop<int32_t>();
    int32_t srcLevel = stack->pop<int32_t>();
    GLenum srcTarget = stack->pop<GLenum>();
    uint32_t 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 ")\n",
                   srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel,
                   dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        if (glCopyImageSubDataEXT != nullptr) {
            glCopyImageSubDataEXT(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
                                  dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                  srcDepth);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCopyImageSubDataEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCopyImageSubDataEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCopyImageSubDataEXT\n");
        return false;
    }
}

bool callGlDebugMessageCallbackKHR(Stack* stack, bool pushReturn) {
    void* userParam = stack->pop<void*>();
    void* callback = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glDebugMessageCallbackKHR(%p, %p)\n", callback, userParam);
        if (glDebugMessageCallbackKHR != nullptr) {
            glDebugMessageCallbackKHR(callback, userParam);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDebugMessageCallbackKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDebugMessageCallbackKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDebugMessageCallbackKHR\n");
        return false;
    }
}

bool callGlDebugMessageControlKHR(Stack* stack, bool pushReturn) {
    uint8_t enabled = stack->pop<uint8_t>();
    uint32_t* ids = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    GLenum severity = stack->pop<GLenum>();
    GLenum type = stack->pop<GLenum>();
    GLenum source = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDebugMessageControlKHR(%u, %u, %u, %" PRId32 ", %p, %" PRIu8 ")\n", source,
                   type, severity, count, ids, enabled);
        if (glDebugMessageControlKHR != nullptr) {
            glDebugMessageControlKHR(source, type, severity, count, ids, enabled);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDebugMessageControlKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDebugMessageControlKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDebugMessageControlKHR\n");
        return false;
    }
}

bool callGlDebugMessageInsertKHR(Stack* stack, bool pushReturn) {
    char* buf = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    GLenum severity = stack->pop<GLenum>();
    uint32_t id = stack->pop<uint32_t>();
    GLenum type = stack->pop<GLenum>();
    GLenum source = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDebugMessageInsertKHR(%u, %u, %" PRIu32 ", %u, %" PRId32 ", %p)\n", source,
                   type, id, severity, length, buf);
        if (glDebugMessageInsertKHR != nullptr) {
            glDebugMessageInsertKHR(source, type, id, severity, length, buf);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDebugMessageInsertKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDebugMessageInsertKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDebugMessageInsertKHR\n");
        return false;
    }
}

bool callGlDisableiEXT(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDisableiEXT(%u, %" PRIu32 ")\n", target, index);
        if (glDisableiEXT != nullptr) {
            glDisableiEXT(target, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDisableiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDisableiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDisableiEXT\n");
        return false;
    }
}

bool callGlEnableiEXT(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEnableiEXT(%u, %" PRIu32 ")\n", target, index);
        if (glEnableiEXT != nullptr) {
            glEnableiEXT(target, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEnableiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEnableiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEnableiEXT\n");
        return false;
    }
}

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

bool callGlGetDebugMessageLogKHR(Stack* stack, bool pushReturn) {
    char* messageLog = stack->pop<char*>();
    int32_t* lengths = stack->pop<int32_t*>();
    GLenum* severities = stack->pop<GLenum*>();
    uint32_t* ids = stack->pop<uint32_t*>();
    GLenum* types = stack->pop<GLenum*>();
    GLenum* sources = stack->pop<GLenum*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t count = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetDebugMessageLogKHR(%" PRIu32 ", %" PRId32 ", %p, %p, %p, %p, %p, %p)\n",
                   count, bufSize, sources, types, ids, severities, lengths, messageLog);
        if (glGetDebugMessageLogKHR != nullptr) {
            uint32_t return_value = glGetDebugMessageLogKHR(count, bufSize, sources, types, ids,
                                                            severities, lengths, messageLog);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetDebugMessageLogKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetDebugMessageLogKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetDebugMessageLogKHR\n");
        return false;
    }
}

bool callGlGetObjectLabelKHR(Stack* stack, bool pushReturn) {
    char* label = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t name = stack->pop<uint32_t>();
    GLenum identifier = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetObjectLabelKHR(%u, %" PRIu32 ", %" PRId32 ", %p, %p)\n", identifier, name,
                   bufSize, length, label);
        if (glGetObjectLabelKHR != nullptr) {
            glGetObjectLabelKHR(identifier, name, bufSize, length, label);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetObjectLabelKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetObjectLabelKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetObjectLabelKHR\n");
        return false;
    }
}

bool callGlGetObjectPtrLabelKHR(Stack* stack, bool pushReturn) {
    char* label = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    void* ptr = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glGetObjectPtrLabelKHR(%p, %" PRId32 ", %p, %p)\n", ptr, bufSize, length,
                   label);
        if (glGetObjectPtrLabelKHR != nullptr) {
            glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetObjectPtrLabelKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetObjectPtrLabelKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetObjectPtrLabelKHR\n");
        return false;
    }
}

bool callGlGetPointervKHR(Stack* stack, bool pushReturn) {
    void** params = stack->pop<void**>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPointervKHR(%u, %p)\n", pname, params);
        if (glGetPointervKHR != nullptr) {
            glGetPointervKHR(pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPointervKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPointervKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPointervKHR\n");
        return false;
    }
}

bool callGlGetSamplerParameterIivEXT(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSamplerParameterIivEXT(%" PRIu32 ", %u, %p)\n", sampler, pname, params);
        if (glGetSamplerParameterIivEXT != nullptr) {
            glGetSamplerParameterIivEXT(sampler, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSamplerParameterIivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSamplerParameterIivEXT\n");
        return false;
    }
}

bool callGlGetSamplerParameterIuivEXT(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSamplerParameterIuivEXT(%" PRIu32 ", %u, %p)\n", sampler, pname, params);
        if (glGetSamplerParameterIuivEXT != nullptr) {
            glGetSamplerParameterIuivEXT(sampler, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSamplerParameterIuivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIuivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSamplerParameterIuivEXT\n");
        return false;
    }
}

bool callGlGetTexParameterIivEXT(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexParameterIivEXT(%u, %u, %p)\n", target, pname, params);
        if (glGetTexParameterIivEXT != nullptr) {
            glGetTexParameterIivEXT(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexParameterIivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexParameterIivEXT\n");
        return false;
    }
}

bool callGlGetTexParameterIuivEXT(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexParameterIuivEXT(%u, %u, %p)\n", target, pname, params);
        if (glGetTexParameterIuivEXT != nullptr) {
            glGetTexParameterIuivEXT(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexParameterIuivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIuivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexParameterIuivEXT\n");
        return false;
    }
}

bool callGlIsEnablediEXT(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glIsEnablediEXT(%u, %" PRIu32 ")\n", target, index);
        if (glIsEnablediEXT != nullptr) {
            bool return_value = glIsEnablediEXT(target, index);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsEnablediEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsEnablediEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsEnablediEXT\n");
        return false;
    }
}

bool callGlMinSampleShadingOES(Stack* stack, bool pushReturn) {
    float value = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glMinSampleShadingOES(%f)\n", value);
        if (glMinSampleShadingOES != nullptr) {
            glMinSampleShadingOES(value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMinSampleShadingOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMinSampleShadingOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMinSampleShadingOES\n");
        return false;
    }
}

bool callGlObjectLabelKHR(Stack* stack, bool pushReturn) {
    char* label = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    uint32_t name = stack->pop<uint32_t>();
    GLenum identifier = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glObjectLabelKHR(%u, %" PRIu32 ", %" PRId32 ", %p)\n", identifier, name, length,
                   label);
        if (glObjectLabelKHR != nullptr) {
            glObjectLabelKHR(identifier, name, length, label);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glObjectLabelKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glObjectLabelKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glObjectLabelKHR\n");
        return false;
    }
}

bool callGlObjectPtrLabelKHR(Stack* stack, bool pushReturn) {
    char* label = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    void* ptr = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glObjectPtrLabelKHR(%p, %" PRId32 ", %p)\n", ptr, length, label);
        if (glObjectPtrLabelKHR != nullptr) {
            glObjectPtrLabelKHR(ptr, length, label);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glObjectPtrLabelKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glObjectPtrLabelKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glObjectPtrLabelKHR\n");
        return false;
    }
}

bool callGlPatchParameteriEXT(Stack* stack, bool pushReturn) {
    int32_t value = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glPatchParameteriEXT(%u, %" PRId32 ")\n", pname, value);
        if (glPatchParameteriEXT != nullptr) {
            glPatchParameteriEXT(pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPatchParameteriEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPatchParameteriEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPatchParameteriEXT\n");
        return false;
    }
}

bool callGlPopDebugGroupKHR(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glPopDebugGroupKHR()\n");
        if (glPopDebugGroupKHR != nullptr) {
            glPopDebugGroupKHR();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPopDebugGroupKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPopDebugGroupKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPopDebugGroupKHR\n");
        return false;
    }
}

bool callGlPrimitiveBoundingBoxEXT(Stack* stack, bool pushReturn) {
    float maxW = stack->pop<float>();
    float maxZ = stack->pop<float>();
    float maxY = stack->pop<float>();
    float maxX = stack->pop<float>();
    float minW = stack->pop<float>();
    float minZ = stack->pop<float>();
    float minY = stack->pop<float>();
    float minX = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glPrimitiveBoundingBoxEXT(%f, %f, %f, %f, %f, %f, %f, %f)\n", minX, minY, minZ,
                   minW, maxX, maxY, maxZ, maxW);
        if (glPrimitiveBoundingBoxEXT != nullptr) {
            glPrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPrimitiveBoundingBoxEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPrimitiveBoundingBoxEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPrimitiveBoundingBoxEXT\n");
        return false;
    }
}

bool callGlPushDebugGroupKHR(Stack* stack, bool pushReturn) {
    char* message = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    uint32_t id = stack->pop<uint32_t>();
    GLenum source = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glPushDebugGroupKHR(%u, %" PRIu32 ", %" PRId32 ", %p)\n", source, id, length,
                   message);
        if (glPushDebugGroupKHR != nullptr) {
            glPushDebugGroupKHR(source, id, length, message);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPushDebugGroupKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPushDebugGroupKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPushDebugGroupKHR\n");
        return false;
    }
}

bool callGlSamplerParameterIivEXT(Stack* stack, bool pushReturn) {
    int32_t* param = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSamplerParameterIivEXT(%" PRIu32 ", %u, %p)\n", sampler, pname, param);
        if (glSamplerParameterIivEXT != nullptr) {
            glSamplerParameterIivEXT(sampler, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSamplerParameterIivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSamplerParameterIivEXT\n");
        return false;
    }
}

bool callGlSamplerParameterIuivEXT(Stack* stack, bool pushReturn) {
    uint32_t* param = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSamplerParameterIuivEXT(%" PRIu32 ", %u, %p)\n", sampler, pname, param);
        if (glSamplerParameterIuivEXT != nullptr) {
            glSamplerParameterIuivEXT(sampler, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSamplerParameterIuivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIuivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSamplerParameterIuivEXT\n");
        return false;
    }
}

bool callGlTexBufferEXT(Stack* stack, bool pushReturn) {
    uint32_t buffer = stack->pop<uint32_t>();
    GLenum internalformat = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexBufferEXT(%u, %u, %" PRIu32 ")\n", target, internalformat, buffer);
        if (glTexBufferEXT != nullptr) {
            glTexBufferEXT(target, internalformat, buffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexBufferEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexBufferEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexBufferEXT\n");
        return false;
    }
}

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

bool callGlTexParameterIivEXT(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameterIivEXT(%u, %u, %p)\n", target, pname, params);
        if (glTexParameterIivEXT != nullptr) {
            glTexParameterIivEXT(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameterIivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameterIivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameterIivEXT\n");
        return false;
    }
}

bool callGlTexParameterIuivEXT(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameterIuivEXT(%u, %u, %p)\n", target, pname, params);
        if (glTexParameterIuivEXT != nullptr) {
            glTexParameterIuivEXT(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameterIuivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameterIuivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameterIuivEXT\n");
        return false;
    }
}

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

bool callGlBeginQuery(Stack* stack, bool pushReturn) {
    uint32_t query = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBeginQuery(%u, %" PRIu32 ")\n", target, query);
        if (glBeginQuery != nullptr) {
            glBeginQuery(target, query);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBeginQuery returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBeginQuery\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBeginQuery\n");
        return false;
    }
}

bool callGlDeleteQueries(Stack* stack, bool pushReturn) {
    uint32_t* queries = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteQueries(%" PRId32 ", %p)\n", count, queries);
        if (glDeleteQueries != nullptr) {
            glDeleteQueries(count, queries);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteQueries returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteQueries\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteQueries\n");
        return false;
    }
}

bool callGlEndQuery(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEndQuery(%u)\n", target);
        if (glEndQuery != nullptr) {
            glEndQuery(target);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndQuery returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndQuery\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndQuery\n");
        return false;
    }
}

bool callGlGenQueries(Stack* stack, bool pushReturn) {
    uint32_t* queries = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenQueries(%" PRId32 ", %p)\n", count, queries);
        if (glGenQueries != nullptr) {
            glGenQueries(count, queries);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenQueries returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenQueries\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenQueries\n");
        return false;
    }
}

bool callGlGetQueryObjectuiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryObjectuiv(%" PRIu32 ", %u, %p)\n", query, parameter, value);
        if (glGetQueryObjectuiv != nullptr) {
            glGetQueryObjectuiv(query, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryObjectuiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectuiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryObjectuiv\n");
        return false;
    }
}

bool callGlGetQueryiv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryiv(%u, %u, %p)\n", target, parameter, value);
        if (glGetQueryiv != nullptr) {
            glGetQueryiv(target, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryiv\n");
        return false;
    }
}

bool callGlIsQuery(Stack* stack, bool pushReturn) {
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsQuery(%" PRIu32 ")\n", query);
        if (glIsQuery != nullptr) {
            bool return_value = glIsQuery(query);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsQuery returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsQuery\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsQuery\n");
        return false;
    }
}

bool callGlBindBuffer(Stack* stack, bool pushReturn) {
    uint32_t buffer = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBindBuffer(%u, %" PRIu32 ")\n", target, buffer);
        if (glBindBuffer != nullptr) {
            glBindBuffer(target, buffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindBuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindBuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindBuffer\n");
        return false;
    }
}

bool callGlBindBufferBase(Stack* stack, bool pushReturn) {
    uint32_t buffer = stack->pop<uint32_t>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBindBufferBase(%u, %" PRIu32 ", %" PRIu32 ")\n", target, index, buffer);
        if (glBindBufferBase != nullptr) {
            glBindBufferBase(target, index, buffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindBufferBase returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindBufferBase\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindBufferBase\n");
        return false;
    }
}

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

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

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

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

bool callGlDeleteBuffers(Stack* stack, bool pushReturn) {
    uint32_t* buffers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteBuffers(%" PRId32 ", %p)\n", count, buffers);
        if (glDeleteBuffers != nullptr) {
            glDeleteBuffers(count, buffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteBuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteBuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteBuffers\n");
        return false;
    }
}

bool callGlGenBuffers(Stack* stack, bool pushReturn) {
    uint32_t* buffers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenBuffers(%" PRId32 ", %p)\n", count, buffers);
        if (glGenBuffers != nullptr) {
            glGenBuffers(count, buffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenBuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenBuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenBuffers\n");
        return false;
    }
}

bool callGlGetBufferParameteri64v(Stack* stack, bool pushReturn) {
    int64_t* params = stack->pop<int64_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetBufferParameteri64v(%u, %u, %p)\n", target, pname, params);
        if (glGetBufferParameteri64v != nullptr) {
            glGetBufferParameteri64v(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetBufferParameteri64v returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetBufferParameteri64v\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetBufferParameteri64v\n");
        return false;
    }
}

bool callGlGetBufferParameteriv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetBufferParameteriv(%u, %u, %p)\n", target, parameter, value);
        if (glGetBufferParameteriv != nullptr) {
            glGetBufferParameteriv(target, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetBufferParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetBufferParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetBufferParameteriv\n");
        return false;
    }
}

bool callGlGetBufferPointerv(Stack* stack, bool pushReturn) {
    void** params = stack->pop<void**>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetBufferPointerv(%u, %u, %p)\n", target, pname, params);
        if (glGetBufferPointerv != nullptr) {
            glGetBufferPointerv(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetBufferPointerv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetBufferPointerv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetBufferPointerv\n");
        return false;
    }
}

bool callGlIsBuffer(Stack* stack, bool pushReturn) {
    uint32_t buffer = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsBuffer(%" PRIu32 ")\n", buffer);
        if (glIsBuffer != nullptr) {
            bool return_value = glIsBuffer(buffer);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsBuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsBuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsBuffer\n");
        return false;
    }
}

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

bool callGlUnmapBuffer(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glUnmapBuffer(%u)\n", target);
        if (glUnmapBuffer != nullptr) {
            uint8_t return_value = glUnmapBuffer(target);
            GAPID_INFO("Returned: %" PRIu8 "\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUnmapBuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUnmapBuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUnmapBuffer\n");
        return false;
    }
}

bool callGlDrawArrays(Stack* stack, bool pushReturn) {
    int32_t index_count = stack->pop<int32_t>();
    int32_t first_index = stack->pop<int32_t>();
    GLenum draw_mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawArrays(%u, %" PRId32 ", %" PRId32 ")\n", draw_mode, first_index,
                   index_count);
        if (glDrawArrays != nullptr) {
            glDrawArrays(draw_mode, first_index, index_count);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawArrays returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawArrays\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawArrays\n");
        return false;
    }
}

bool callGlDrawArraysIndirect(Stack* stack, bool pushReturn) {
    void* indirect = stack->pop<void*>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawArraysIndirect(%u, %p)\n", mode, indirect);
        if (glDrawArraysIndirect != nullptr) {
            glDrawArraysIndirect(mode, indirect);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawArraysIndirect returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawArraysIndirect\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawArraysIndirect\n");
        return false;
    }
}

bool callGlDrawArraysInstanced(Stack* stack, bool pushReturn) {
    int32_t instancecount = stack->pop<int32_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t first = stack->pop<int32_t>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawArraysInstanced(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", mode,
                   first, count, instancecount);
        if (glDrawArraysInstanced != nullptr) {
            glDrawArraysInstanced(mode, first, count, instancecount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawArraysInstanced returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstanced\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawArraysInstanced\n");
        return false;
    }
}

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

bool callGlDrawElements(Stack* stack, bool pushReturn) {
    void* indices = stack->pop<void*>();
    GLenum indices_type = stack->pop<GLenum>();
    int32_t element_count = stack->pop<int32_t>();
    GLenum draw_mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawElements(%u, %" PRId32 ", %u, %p)\n", draw_mode, element_count,
                   indices_type, indices);
        if (glDrawElements != nullptr) {
            glDrawElements(draw_mode, element_count, indices_type, indices);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawElements returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawElements\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawElements\n");
        return false;
    }
}

bool callGlDrawElementsIndirect(Stack* stack, bool pushReturn) {
    void* indirect = stack->pop<void*>();
    GLenum type = stack->pop<GLenum>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawElementsIndirect(%u, %u, %p)\n", mode, type, indirect);
        if (glDrawElementsIndirect != nullptr) {
            glDrawElementsIndirect(mode, type, indirect);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawElementsIndirect returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawElementsIndirect\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawElementsIndirect\n");
        return false;
    }
}

bool callGlDrawElementsInstanced(Stack* stack, bool pushReturn) {
    int32_t instancecount = stack->pop<int32_t>();
    void* indices = stack->pop<void*>();
    GLenum type = stack->pop<GLenum>();
    int32_t count = stack->pop<int32_t>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawElementsInstanced(%u, %" PRId32 ", %u, %p, %" PRId32 ")\n", mode, count,
                   type, indices, instancecount);
        if (glDrawElementsInstanced != nullptr) {
            glDrawElementsInstanced(mode, count, type, indices, instancecount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawElementsInstanced returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawElementsInstanced\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawElementsInstanced\n");
        return false;
    }
}

bool callGlDrawRangeElements(Stack* stack, bool pushReturn) {
    void* indices = stack->pop<void*>();
    GLenum type = stack->pop<GLenum>();
    int32_t count = stack->pop<int32_t>();
    uint32_t end = stack->pop<uint32_t>();
    uint32_t start = stack->pop<uint32_t>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawRangeElements(%u, %" PRIu32 ", %" PRIu32 ", %" PRId32 ", %u, %p)\n", mode,
                   start, end, count, type, indices);
        if (glDrawRangeElements != nullptr) {
            glDrawRangeElements(mode, start, end, count, type, indices);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawRangeElements returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawRangeElements\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawRangeElements\n");
        return false;
    }
}

bool callGlActiveShaderProgramEXT(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glActiveShaderProgramEXT(%" PRIu32 ", %" PRIu32 ")\n", pipeline, program);
        if (glActiveShaderProgramEXT != nullptr) {
            glActiveShaderProgramEXT(pipeline, program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glActiveShaderProgramEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glActiveShaderProgramEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glActiveShaderProgramEXT\n");
        return false;
    }
}

bool callGlAlphaFuncQCOM(Stack* stack, bool pushReturn) {
    float ref = stack->pop<float>();
    GLenum func = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glAlphaFuncQCOM(%u, %f)\n", func, ref);
        if (glAlphaFuncQCOM != nullptr) {
            glAlphaFuncQCOM(func, ref);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glAlphaFuncQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glAlphaFuncQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glAlphaFuncQCOM\n");
        return false;
    }
}

bool callGlBeginConditionalRenderNV(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    uint32_t id = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBeginConditionalRenderNV(%" PRIu32 ", %u)\n", id, mode);
        if (glBeginConditionalRenderNV != nullptr) {
            glBeginConditionalRenderNV(id, mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBeginConditionalRenderNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBeginConditionalRenderNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBeginConditionalRenderNV\n");
        return false;
    }
}

bool callGlBeginPerfMonitorAMD(Stack* stack, bool pushReturn) {
    uint32_t monitor = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBeginPerfMonitorAMD(%" PRIu32 ")\n", monitor);
        if (glBeginPerfMonitorAMD != nullptr) {
            glBeginPerfMonitorAMD(monitor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBeginPerfMonitorAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBeginPerfMonitorAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBeginPerfMonitorAMD\n");
        return false;
    }
}

bool callGlBeginPerfQueryINTEL(Stack* stack, bool pushReturn) {
    uint32_t queryHandle = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBeginPerfQueryINTEL(%" PRIu32 ")\n", queryHandle);
        if (glBeginPerfQueryINTEL != nullptr) {
            glBeginPerfQueryINTEL(queryHandle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBeginPerfQueryINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBeginPerfQueryINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBeginPerfQueryINTEL\n");
        return false;
    }
}

bool callGlBeginQueryEXT(Stack* stack, bool pushReturn) {
    uint32_t query = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBeginQueryEXT(%u, %" PRIu32 ")\n", target, query);
        if (glBeginQueryEXT != nullptr) {
            glBeginQueryEXT(target, query);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBeginQueryEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBeginQueryEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBeginQueryEXT\n");
        return false;
    }
}

bool callGlBindProgramPipelineEXT(Stack* stack, bool pushReturn) {
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindProgramPipelineEXT(%" PRIu32 ")\n", pipeline);
        if (glBindProgramPipelineEXT != nullptr) {
            glBindProgramPipelineEXT(pipeline);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindProgramPipelineEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindProgramPipelineEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindProgramPipelineEXT\n");
        return false;
    }
}

bool callGlBindVertexArrayOES(Stack* stack, bool pushReturn) {
    uint32_t array = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindVertexArrayOES(%" PRIu32 ")\n", array);
        if (glBindVertexArrayOES != nullptr) {
            glBindVertexArrayOES(array);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindVertexArrayOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindVertexArrayOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindVertexArrayOES\n");
        return false;
    }
}

bool callGlBlendBarrierNV(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glBlendBarrierNV()\n");
        if (glBlendBarrierNV != nullptr) {
            glBlendBarrierNV();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendBarrierNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendBarrierNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendBarrierNV\n");
        return false;
    }
}

bool callGlBlendEquationSeparateiOES(Stack* stack, bool pushReturn) {
    GLenum modeAlpha = stack->pop<GLenum>();
    GLenum modeRGB = stack->pop<GLenum>();
    uint32_t buf = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendEquationSeparateiOES(%" PRIu32 ", %u, %u)\n", buf, modeRGB, modeAlpha);
        if (glBlendEquationSeparateiOES != nullptr) {
            glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendEquationSeparateiOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparateiOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendEquationSeparateiOES\n");
        return false;
    }
}

bool callGlBlendEquationiOES(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    uint32_t buf = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendEquationiOES(%" PRIu32 ", %u)\n", buf, mode);
        if (glBlendEquationiOES != nullptr) {
            glBlendEquationiOES(buf, mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendEquationiOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendEquationiOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendEquationiOES\n");
        return false;
    }
}

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

bool callGlBlendFunciOES(Stack* stack, bool pushReturn) {
    GLenum dst = stack->pop<GLenum>();
    GLenum src = stack->pop<GLenum>();
    uint32_t buf = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendFunciOES(%" PRIu32 ", %u, %u)\n", buf, src, dst);
        if (glBlendFunciOES != nullptr) {
            glBlendFunciOES(buf, src, dst);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendFunciOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendFunciOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendFunciOES\n");
        return false;
    }
}

bool callGlBlendParameteriNV(Stack* stack, bool pushReturn) {
    int32_t value = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendParameteriNV(%u, %" PRId32 ")\n", pname, value);
        if (glBlendParameteriNV != nullptr) {
            glBlendParameteriNV(pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendParameteriNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendParameteriNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendParameteriNV\n");
        return false;
    }
}

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

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

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

bool callGlClientWaitSyncAPPLE(Stack* stack, bool pushReturn) {
    uint64_t timeout = stack->pop<uint64_t>();
    GLbitfield flag = stack->pop<GLbitfield>();
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glClientWaitSyncAPPLE(%" PRIu64 ", %u, %" PRIu64 ")\n", sync, flag, timeout);
        if (glClientWaitSyncAPPLE != nullptr) {
            GLenum return_value = glClientWaitSyncAPPLE(sync, flag, timeout);
            GAPID_INFO("Returned: %u\n", return_value);
            if (pushReturn) {
                stack->push<GLenum>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClientWaitSyncAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClientWaitSyncAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClientWaitSyncAPPLE\n");
        return false;
    }
}

bool callGlColorMaskiOES(Stack* stack, bool pushReturn) {
    uint8_t a = stack->pop<uint8_t>();
    uint8_t b = stack->pop<uint8_t>();
    uint8_t g = stack->pop<uint8_t>();
    uint8_t r = stack->pop<uint8_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glColorMaskiOES(%" PRIu32 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")\n",
                   index, r, g, b, a);
        if (glColorMaskiOES != nullptr) {
            glColorMaskiOES(index, r, g, b, a);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glColorMaskiOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glColorMaskiOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glColorMaskiOES\n");
        return false;
    }
}

bool callGlCompressedTexImage3DOES(Stack* stack, bool pushReturn) {
    void* data = stack->pop<void*>();
    int32_t imageSize = stack->pop<int32_t>();
    int32_t border = stack->pop<int32_t>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    GLenum internalformat = stack->pop<GLenum>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCompressedTexImage3DOES(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %p)\n",
                   target, level, internalformat, width, height, depth, border, imageSize, data);
        if (glCompressedTexImage3DOES != nullptr) {
            glCompressedTexImage3DOES(target, level, internalformat, width, height, depth, border,
                                      imageSize, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCompressedTexImage3DOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCompressedTexImage3DOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCompressedTexImage3DOES\n");
        return false;
    }
}

bool callGlCompressedTexSubImage3DOES(Stack* stack, bool pushReturn) {
    void* data = stack->pop<void*>();
    int32_t imageSize = stack->pop<int32_t>();
    GLenum format = stack->pop<GLenum>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t zoffset = stack->pop<int32_t>();
    int32_t yoffset = stack->pop<int32_t>();
    int32_t xoffset = stack->pop<int32_t>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCompressedTexSubImage3DOES(%u, %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %" PRId32 ", %p)\n",
                   target, level, xoffset, yoffset, zoffset, width, height, depth, format,
                   imageSize, data);
        if (glCompressedTexSubImage3DOES != nullptr) {
            glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height,
                                         depth, format, imageSize, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCompressedTexSubImage3DOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCompressedTexSubImage3DOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCompressedTexSubImage3DOES\n");
        return false;
    }
}

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

bool callGlCopyImageSubDataOES(Stack* stack, bool pushReturn) {
    int32_t srcDepth = stack->pop<int32_t>();
    int32_t srcHeight = stack->pop<int32_t>();
    int32_t srcWidth = stack->pop<int32_t>();
    int32_t dstZ = stack->pop<int32_t>();
    int32_t dstY = stack->pop<int32_t>();
    int32_t dstX = stack->pop<int32_t>();
    int32_t dstLevel = stack->pop<int32_t>();
    GLenum dstTarget = stack->pop<GLenum>();
    uint32_t dstName = stack->pop<uint32_t>();
    int32_t srcZ = stack->pop<int32_t>();
    int32_t srcY = stack->pop<int32_t>();
    int32_t srcX = stack->pop<int32_t>();
    int32_t srcLevel = stack->pop<int32_t>();
    GLenum srcTarget = stack->pop<GLenum>();
    uint32_t 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 ")\n",
                   srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel,
                   dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
        if (glCopyImageSubDataOES != nullptr) {
            glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName,
                                  dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight,
                                  srcDepth);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCopyImageSubDataOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCopyImageSubDataOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCopyImageSubDataOES\n");
        return false;
    }
}

bool callGlCopyPathNV(Stack* stack, bool pushReturn) {
    uint32_t srcPath = stack->pop<uint32_t>();
    uint32_t resultPath = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCopyPathNV(%" PRIu32 ", %" PRIu32 ")\n", resultPath, srcPath);
        if (glCopyPathNV != nullptr) {
            glCopyPathNV(resultPath, srcPath);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCopyPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCopyPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCopyPathNV\n");
        return false;
    }
}

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

bool callGlCopyTextureLevelsAPPLE(Stack* stack, bool pushReturn) {
    int32_t sourceLevelCount = stack->pop<int32_t>();
    int32_t sourceBaseLevel = stack->pop<int32_t>();
    uint32_t sourceTexture = stack->pop<uint32_t>();
    uint32_t destinationTexture = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCopyTextureLevelsAPPLE(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")\n",
                   destinationTexture, sourceTexture, sourceBaseLevel, sourceLevelCount);
        if (glCopyTextureLevelsAPPLE != nullptr) {
            glCopyTextureLevelsAPPLE(destinationTexture, sourceTexture, sourceBaseLevel,
                                     sourceLevelCount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCopyTextureLevelsAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCopyTextureLevelsAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCopyTextureLevelsAPPLE\n");
        return false;
    }
}

bool callGlCoverFillPathInstancedNV(Stack* stack, bool pushReturn) {
    float* transformValues = stack->pop<float*>();
    GLenum transformType = stack->pop<GLenum>();
    GLenum coverMode = stack->pop<GLenum>();
    uint32_t pathBase = stack->pop<uint32_t>();
    void* paths = stack->pop<void*>();
    GLenum pathNameType = stack->pop<GLenum>();
    int32_t numPaths = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %u, %p)\n",
                   numPaths, pathNameType, paths, pathBase, coverMode, transformType,
                   transformValues);
        if (glCoverFillPathInstancedNV != nullptr) {
            glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode,
                                       transformType, transformValues);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverFillPathInstancedNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverFillPathInstancedNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverFillPathInstancedNV\n");
        return false;
    }
}

bool callGlCoverFillPathNV(Stack* stack, bool pushReturn) {
    GLenum coverMode = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverFillPathNV(%" PRIu32 ", %u)\n", path, coverMode);
        if (glCoverFillPathNV != nullptr) {
            glCoverFillPathNV(path, coverMode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverFillPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverFillPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverFillPathNV\n");
        return false;
    }
}

bool callGlCoverStrokePathInstancedNV(Stack* stack, bool pushReturn) {
    float* transformValues = stack->pop<float*>();
    GLenum transformType = stack->pop<GLenum>();
    GLenum coverMode = stack->pop<GLenum>();
    uint32_t pathBase = stack->pop<uint32_t>();
    void* paths = stack->pop<void*>();
    GLenum pathNameType = stack->pop<GLenum>();
    int32_t numPaths = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %u, %p)\n",
                   numPaths, pathNameType, paths, pathBase, coverMode, transformType,
                   transformValues);
        if (glCoverStrokePathInstancedNV != nullptr) {
            glCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode,
                                         transformType, transformValues);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverStrokePathInstancedNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverStrokePathInstancedNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverStrokePathInstancedNV\n");
        return false;
    }
}

bool callGlCoverStrokePathNV(Stack* stack, bool pushReturn) {
    GLenum coverMode = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverStrokePathNV(%" PRIu32 ", %u)\n", path, coverMode);
        if (glCoverStrokePathNV != nullptr) {
            glCoverStrokePathNV(path, coverMode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverStrokePathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverStrokePathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverStrokePathNV\n");
        return false;
    }
}

bool callGlCoverageMaskNV(Stack* stack, bool pushReturn) {
    uint8_t mask = stack->pop<uint8_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverageMaskNV(%" PRIu8 ")\n", mask);
        if (glCoverageMaskNV != nullptr) {
            glCoverageMaskNV(mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverageMaskNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverageMaskNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverageMaskNV\n");
        return false;
    }
}

bool callGlCoverageOperationNV(Stack* stack, bool pushReturn) {
    GLenum operation = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverageOperationNV(%u)\n", operation);
        if (glCoverageOperationNV != nullptr) {
            glCoverageOperationNV(operation);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverageOperationNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverageOperationNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverageOperationNV\n");
        return false;
    }
}

bool callGlCreatePerfQueryINTEL(Stack* stack, bool pushReturn) {
    uint32_t* queryHandle = stack->pop<uint32_t*>();
    uint32_t queryId = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCreatePerfQueryINTEL(%" PRIu32 ", %p)\n", queryId, queryHandle);
        if (glCreatePerfQueryINTEL != nullptr) {
            glCreatePerfQueryINTEL(queryId, queryHandle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCreatePerfQueryINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCreatePerfQueryINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCreatePerfQueryINTEL\n");
        return false;
    }
}

bool callGlCreateShaderProgramvEXT(Stack* stack, bool pushReturn) {
    char** strings = stack->pop<char**>();
    int32_t count = stack->pop<int32_t>();
    GLenum type = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCreateShaderProgramvEXT(%u, %" PRId32 ", %p)\n", type, count, strings);
        if (glCreateShaderProgramvEXT != nullptr) {
            uint32_t return_value = glCreateShaderProgramvEXT(type, count, strings);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCreateShaderProgramvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCreateShaderProgramvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCreateShaderProgramvEXT\n");
        return false;
    }
}

bool callGlDeleteFencesNV(Stack* stack, bool pushReturn) {
    uint32_t* fences = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteFencesNV(%" PRId32 ", %p)\n", n, fences);
        if (glDeleteFencesNV != nullptr) {
            glDeleteFencesNV(n, fences);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteFencesNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteFencesNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteFencesNV\n");
        return false;
    }
}

bool callGlDeletePathsNV(Stack* stack, bool pushReturn) {
    int32_t range = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeletePathsNV(%" PRIu32 ", %" PRId32 ")\n", path, range);
        if (glDeletePathsNV != nullptr) {
            glDeletePathsNV(path, range);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeletePathsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeletePathsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeletePathsNV\n");
        return false;
    }
}

bool callGlDeletePerfMonitorsAMD(Stack* stack, bool pushReturn) {
    uint32_t* monitors = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeletePerfMonitorsAMD(%" PRId32 ", %p)\n", n, monitors);
        if (glDeletePerfMonitorsAMD != nullptr) {
            glDeletePerfMonitorsAMD(n, monitors);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeletePerfMonitorsAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeletePerfMonitorsAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeletePerfMonitorsAMD\n");
        return false;
    }
}

bool callGlDeletePerfQueryINTEL(Stack* stack, bool pushReturn) {
    uint32_t queryHandle = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeletePerfQueryINTEL(%" PRIu32 ")\n", queryHandle);
        if (glDeletePerfQueryINTEL != nullptr) {
            glDeletePerfQueryINTEL(queryHandle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeletePerfQueryINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeletePerfQueryINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeletePerfQueryINTEL\n");
        return false;
    }
}

bool callGlDeleteProgramPipelinesEXT(Stack* stack, bool pushReturn) {
    uint32_t* pipelines = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteProgramPipelinesEXT(%" PRId32 ", %p)\n", n, pipelines);
        if (glDeleteProgramPipelinesEXT != nullptr) {
            glDeleteProgramPipelinesEXT(n, pipelines);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteProgramPipelinesEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteProgramPipelinesEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteProgramPipelinesEXT\n");
        return false;
    }
}

bool callGlDeleteQueriesEXT(Stack* stack, bool pushReturn) {
    uint32_t* queries = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteQueriesEXT(%" PRId32 ", %p)\n", count, queries);
        if (glDeleteQueriesEXT != nullptr) {
            glDeleteQueriesEXT(count, queries);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteQueriesEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteQueriesEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteQueriesEXT\n");
        return false;
    }
}

bool callGlDeleteSyncAPPLE(Stack* stack, bool pushReturn) {
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteSyncAPPLE(%" PRIu64 ")\n", sync);
        if (glDeleteSyncAPPLE != nullptr) {
            glDeleteSyncAPPLE(sync);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteSyncAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteSyncAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteSyncAPPLE\n");
        return false;
    }
}

bool callGlDeleteVertexArraysOES(Stack* stack, bool pushReturn) {
    uint32_t* arrays = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteVertexArraysOES(%" PRId32 ", %p)\n", count, arrays);
        if (glDeleteVertexArraysOES != nullptr) {
            glDeleteVertexArraysOES(count, arrays);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteVertexArraysOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteVertexArraysOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteVertexArraysOES\n");
        return false;
    }
}

bool callGlDepthRangeArrayfvNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    uint32_t first = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDepthRangeArrayfvNV(%" PRIu32 ", %" PRId32 ", %p)\n", first, count, v);
        if (glDepthRangeArrayfvNV != nullptr) {
            glDepthRangeArrayfvNV(first, count, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDepthRangeArrayfvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthRangeArrayfvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthRangeArrayfvNV\n");
        return false;
    }
}

bool callGlDepthRangeIndexedfNV(Stack* stack, bool pushReturn) {
    float f = stack->pop<float>();
    float n = stack->pop<float>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDepthRangeIndexedfNV(%" PRIu32 ", %f, %f)\n", index, n, f);
        if (glDepthRangeIndexedfNV != nullptr) {
            glDepthRangeIndexedfNV(index, n, f);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDepthRangeIndexedfNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthRangeIndexedfNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthRangeIndexedfNV\n");
        return false;
    }
}

bool callGlDisableDriverControlQCOM(Stack* stack, bool pushReturn) {
    uint32_t driverControl = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDisableDriverControlQCOM(%" PRIu32 ")\n", driverControl);
        if (glDisableDriverControlQCOM != nullptr) {
            glDisableDriverControlQCOM(driverControl);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDisableDriverControlQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDisableDriverControlQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDisableDriverControlQCOM\n");
        return false;
    }
}

bool callGlDisableiNV(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDisableiNV(%u, %" PRIu32 ")\n", target, index);
        if (glDisableiNV != nullptr) {
            glDisableiNV(target, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDisableiNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDisableiNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDisableiNV\n");
        return false;
    }
}

bool callGlDisableiOES(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDisableiOES(%u, %" PRIu32 ")\n", target, index);
        if (glDisableiOES != nullptr) {
            glDisableiOES(target, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDisableiOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDisableiOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDisableiOES\n");
        return false;
    }
}

bool callGlDiscardFramebufferEXT(Stack* stack, bool pushReturn) {
    GLenum* attachments = stack->pop<GLenum*>();
    int32_t numAttachments = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDiscardFramebufferEXT(%u, %" PRId32 ", %p)\n", target, numAttachments,
                   attachments);
        if (glDiscardFramebufferEXT != nullptr) {
            glDiscardFramebufferEXT(target, numAttachments, attachments);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDiscardFramebufferEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDiscardFramebufferEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDiscardFramebufferEXT\n");
        return false;
    }
}

bool callGlDrawArraysInstancedANGLE(Stack* stack, bool pushReturn) {
    int32_t primcount = stack->pop<int32_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t first = stack->pop<int32_t>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawArraysInstancedANGLE(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", mode,
                   first, count, primcount);
        if (glDrawArraysInstancedANGLE != nullptr) {
            glDrawArraysInstancedANGLE(mode, first, count, primcount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawArraysInstancedANGLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedANGLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawArraysInstancedANGLE\n");
        return false;
    }
}

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

bool callGlDrawArraysInstancedEXT(Stack* stack, bool pushReturn) {
    int32_t primcount = stack->pop<int32_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t start = stack->pop<int32_t>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawArraysInstancedEXT(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", mode,
                   start, count, primcount);
        if (glDrawArraysInstancedEXT != nullptr) {
            glDrawArraysInstancedEXT(mode, start, count, primcount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawArraysInstancedEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawArraysInstancedEXT\n");
        return false;
    }
}

bool callGlDrawArraysInstancedNV(Stack* stack, bool pushReturn) {
    int32_t primcount = stack->pop<int32_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t first = stack->pop<int32_t>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawArraysInstancedNV(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", mode,
                   first, count, primcount);
        if (glDrawArraysInstancedNV != nullptr) {
            glDrawArraysInstancedNV(mode, first, count, primcount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawArraysInstancedNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawArraysInstancedNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawArraysInstancedNV\n");
        return false;
    }
}

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

bool callGlDrawBuffersIndexedEXT(Stack* stack, bool pushReturn) {
    int32_t* indices = stack->pop<int32_t*>();
    GLenum* location = stack->pop<GLenum*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDrawBuffersIndexedEXT(%" PRId32 ", %p, %p)\n", n, location, indices);
        if (glDrawBuffersIndexedEXT != nullptr) {
            glDrawBuffersIndexedEXT(n, location, indices);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDrawBuffersIndexedEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDrawBuffersIndexedEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDrawBuffersIndexedEXT\n");
        return false;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

bool callGlEGLImageTargetRenderbufferStorageOES(Stack* stack, bool pushReturn) {
    void* image = stack->pop<void*>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEGLImageTargetRenderbufferStorageOES(%u, %p)\n", target, image);
        if (glEGLImageTargetRenderbufferStorageOES != nullptr) {
            glEGLImageTargetRenderbufferStorageOES(target, image);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEGLImageTargetRenderbufferStorageOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function "
                    "glEGLImageTargetRenderbufferStorageOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEGLImageTargetRenderbufferStorageOES\n");
        return false;
    }
}

bool callGlEGLImageTargetTexture2DOES(Stack* stack, bool pushReturn) {
    void* image = stack->pop<void*>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEGLImageTargetTexture2DOES(%u, %p)\n", target, image);
        if (glEGLImageTargetTexture2DOES != nullptr) {
            glEGLImageTargetTexture2DOES(target, image);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEGLImageTargetTexture2DOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEGLImageTargetTexture2DOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEGLImageTargetTexture2DOES\n");
        return false;
    }
}

bool callGlEnableDriverControlQCOM(Stack* stack, bool pushReturn) {
    uint32_t driverControl = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glEnableDriverControlQCOM(%" PRIu32 ")\n", driverControl);
        if (glEnableDriverControlQCOM != nullptr) {
            glEnableDriverControlQCOM(driverControl);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEnableDriverControlQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEnableDriverControlQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEnableDriverControlQCOM\n");
        return false;
    }
}

bool callGlEnableiNV(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEnableiNV(%u, %" PRIu32 ")\n", target, index);
        if (glEnableiNV != nullptr) {
            glEnableiNV(target, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEnableiNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEnableiNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEnableiNV\n");
        return false;
    }
}

bool callGlEnableiOES(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEnableiOES(%u, %" PRIu32 ")\n", target, index);
        if (glEnableiOES != nullptr) {
            glEnableiOES(target, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEnableiOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEnableiOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEnableiOES\n");
        return false;
    }
}

bool callGlEndConditionalRenderNV(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glEndConditionalRenderNV()\n");
        if (glEndConditionalRenderNV != nullptr) {
            glEndConditionalRenderNV();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndConditionalRenderNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndConditionalRenderNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndConditionalRenderNV\n");
        return false;
    }
}

bool callGlEndPerfMonitorAMD(Stack* stack, bool pushReturn) {
    uint32_t monitor = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glEndPerfMonitorAMD(%" PRIu32 ")\n", monitor);
        if (glEndPerfMonitorAMD != nullptr) {
            glEndPerfMonitorAMD(monitor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndPerfMonitorAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndPerfMonitorAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndPerfMonitorAMD\n");
        return false;
    }
}

bool callGlEndPerfQueryINTEL(Stack* stack, bool pushReturn) {
    uint32_t queryHandle = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glEndPerfQueryINTEL(%" PRIu32 ")\n", queryHandle);
        if (glEndPerfQueryINTEL != nullptr) {
            glEndPerfQueryINTEL(queryHandle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndPerfQueryINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndPerfQueryINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndPerfQueryINTEL\n");
        return false;
    }
}

bool callGlEndQueryEXT(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEndQueryEXT(%u)\n", target);
        if (glEndQueryEXT != nullptr) {
            glEndQueryEXT(target);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndQueryEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndQueryEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndQueryEXT\n");
        return false;
    }
}

bool callGlEndTilingQCOM(Stack* stack, bool pushReturn) {
    GLbitfield preserve_mask = stack->pop<GLbitfield>();
    if (stack->isValid()) {
        GAPID_INFO("glEndTilingQCOM(%u)\n", preserve_mask);
        if (glEndTilingQCOM != nullptr) {
            glEndTilingQCOM(preserve_mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndTilingQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndTilingQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndTilingQCOM\n");
        return false;
    }
}

bool callGlExtGetBufferPointervQCOM(Stack* stack, bool pushReturn) {
    void** params = stack->pop<void**>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetBufferPointervQCOM(%u, %p)\n", target, params);
        if (glExtGetBufferPointervQCOM != nullptr) {
            glExtGetBufferPointervQCOM(target, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetBufferPointervQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetBufferPointervQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetBufferPointervQCOM\n");
        return false;
    }
}

bool callGlExtGetBuffersQCOM(Stack* stack, bool pushReturn) {
    int32_t* numBuffers = stack->pop<int32_t*>();
    int32_t maxBuffers = stack->pop<int32_t>();
    uint32_t* buffers = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetBuffersQCOM(%p, %" PRId32 ", %p)\n", buffers, maxBuffers, numBuffers);
        if (glExtGetBuffersQCOM != nullptr) {
            glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetBuffersQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetBuffersQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetBuffersQCOM\n");
        return false;
    }
}

bool callGlExtGetFramebuffersQCOM(Stack* stack, bool pushReturn) {
    int32_t* numFramebuffers = stack->pop<int32_t*>();
    int32_t maxFramebuffers = stack->pop<int32_t>();
    uint32_t* framebuffers = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetFramebuffersQCOM(%p, %" PRId32 ", %p)\n", framebuffers, maxFramebuffers,
                   numFramebuffers);
        if (glExtGetFramebuffersQCOM != nullptr) {
            glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetFramebuffersQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetFramebuffersQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetFramebuffersQCOM\n");
        return false;
    }
}

bool callGlExtGetProgramBinarySourceQCOM(Stack* stack, bool pushReturn) {
    int32_t* length = stack->pop<int32_t*>();
    char* source = stack->pop<char*>();
    GLenum shadertype = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetProgramBinarySourceQCOM(%" PRIu32 ", %u, %p, %p)\n", program,
                   shadertype, source, length);
        if (glExtGetProgramBinarySourceQCOM != nullptr) {
            glExtGetProgramBinarySourceQCOM(program, shadertype, source, length);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetProgramBinarySourceQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glExtGetProgramBinarySourceQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetProgramBinarySourceQCOM\n");
        return false;
    }
}

bool callGlExtGetProgramsQCOM(Stack* stack, bool pushReturn) {
    int32_t* numPrograms = stack->pop<int32_t*>();
    int32_t maxPrograms = stack->pop<int32_t>();
    uint32_t* programs = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetProgramsQCOM(%p, %" PRId32 ", %p)\n", programs, maxPrograms,
                   numPrograms);
        if (glExtGetProgramsQCOM != nullptr) {
            glExtGetProgramsQCOM(programs, maxPrograms, numPrograms);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetProgramsQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetProgramsQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetProgramsQCOM\n");
        return false;
    }
}

bool callGlExtGetRenderbuffersQCOM(Stack* stack, bool pushReturn) {
    int32_t* numRenderbuffers = stack->pop<int32_t*>();
    int32_t maxRenderbuffers = stack->pop<int32_t>();
    uint32_t* renderbuffers = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetRenderbuffersQCOM(%p, %" PRId32 ", %p)\n", renderbuffers,
                   maxRenderbuffers, numRenderbuffers);
        if (glExtGetRenderbuffersQCOM != nullptr) {
            glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetRenderbuffersQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetRenderbuffersQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetRenderbuffersQCOM\n");
        return false;
    }
}

bool callGlExtGetShadersQCOM(Stack* stack, bool pushReturn) {
    int32_t* numShaders = stack->pop<int32_t*>();
    int32_t maxShaders = stack->pop<int32_t>();
    uint32_t* shaders = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetShadersQCOM(%p, %" PRId32 ", %p)\n", shaders, maxShaders, numShaders);
        if (glExtGetShadersQCOM != nullptr) {
            glExtGetShadersQCOM(shaders, maxShaders, numShaders);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetShadersQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetShadersQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetShadersQCOM\n");
        return false;
    }
}

bool callGlExtGetTexLevelParameterivQCOM(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    int32_t level = stack->pop<int32_t>();
    GLenum face = stack->pop<GLenum>();
    uint32_t texture = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetTexLevelParameterivQCOM(%" PRIu32 ", %u, %" PRId32 ", %u, %p)\n",
                   texture, face, level, pname, params);
        if (glExtGetTexLevelParameterivQCOM != nullptr) {
            glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetTexLevelParameterivQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glExtGetTexLevelParameterivQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetTexLevelParameterivQCOM\n");
        return false;
    }
}

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

bool callGlExtGetTexturesQCOM(Stack* stack, bool pushReturn) {
    int32_t* numTextures = stack->pop<int32_t*>();
    int32_t maxTextures = stack->pop<int32_t>();
    uint32_t* textures = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glExtGetTexturesQCOM(%p, %" PRId32 ", %p)\n", textures, maxTextures,
                   numTextures);
        if (glExtGetTexturesQCOM != nullptr) {
            glExtGetTexturesQCOM(textures, maxTextures, numTextures);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtGetTexturesQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtGetTexturesQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtGetTexturesQCOM\n");
        return false;
    }
}

bool callGlExtIsProgramBinaryQCOM(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glExtIsProgramBinaryQCOM(%" PRIu32 ")\n", program);
        if (glExtIsProgramBinaryQCOM != nullptr) {
            uint8_t return_value = glExtIsProgramBinaryQCOM(program);
            GAPID_INFO("Returned: %" PRIu8 "\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtIsProgramBinaryQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glExtIsProgramBinaryQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtIsProgramBinaryQCOM\n");
        return false;
    }
}

bool callGlExtTexObjectStateOverrideiQCOM(Stack* stack, bool pushReturn) {
    int32_t param = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glExtTexObjectStateOverrideiQCOM(%u, %u, %" PRId32 ")\n", target, pname, param);
        if (glExtTexObjectStateOverrideiQCOM != nullptr) {
            glExtTexObjectStateOverrideiQCOM(target, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glExtTexObjectStateOverrideiQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glExtTexObjectStateOverrideiQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glExtTexObjectStateOverrideiQCOM\n");
        return false;
    }
}

bool callGlFenceSyncAPPLE(Stack* stack, bool pushReturn) {
    GLbitfield flag = stack->pop<GLbitfield>();
    GLenum condition = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFenceSyncAPPLE(%u, %u)\n", condition, flag);
        if (glFenceSyncAPPLE != nullptr) {
            uint64_t return_value = glFenceSyncAPPLE(condition, flag);
            GAPID_INFO("Returned: %" PRIu64 "\n", return_value);
            if (pushReturn) {
                stack->push<uint64_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFenceSyncAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFenceSyncAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFenceSyncAPPLE\n");
        return false;
    }
}

bool callGlFinishFenceNV(Stack* stack, bool pushReturn) {
    uint32_t fence = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glFinishFenceNV(%" PRIu32 ")\n", fence);
        if (glFinishFenceNV != nullptr) {
            glFinishFenceNV(fence);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFinishFenceNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFinishFenceNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFinishFenceNV\n");
        return false;
    }
}

bool callGlFlushMappedBufferRangeEXT(Stack* stack, bool pushReturn) {
    int32_t length = stack->pop<int32_t>();
    int32_t offset = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFlushMappedBufferRangeEXT(%u, %" PRId32 ", %" PRId32 ")\n", target, offset,
                   length);
        if (glFlushMappedBufferRangeEXT != nullptr) {
            glFlushMappedBufferRangeEXT(target, offset, length);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFlushMappedBufferRangeEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFlushMappedBufferRangeEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFlushMappedBufferRangeEXT\n");
        return false;
    }
}

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

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

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

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

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

bool callGlGenFencesNV(Stack* stack, bool pushReturn) {
    uint32_t* fences = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenFencesNV(%" PRId32 ", %p)\n", n, fences);
        if (glGenFencesNV != nullptr) {
            glGenFencesNV(n, fences);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenFencesNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenFencesNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenFencesNV\n");
        return false;
    }
}

bool callGlGenPathsNV(Stack* stack, bool pushReturn) {
    int32_t range = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenPathsNV(%" PRId32 ")\n", range);
        if (glGenPathsNV != nullptr) {
            uint32_t return_value = glGenPathsNV(range);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenPathsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenPathsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenPathsNV\n");
        return false;
    }
}

bool callGlGenPerfMonitorsAMD(Stack* stack, bool pushReturn) {
    uint32_t* monitors = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenPerfMonitorsAMD(%" PRId32 ", %p)\n", n, monitors);
        if (glGenPerfMonitorsAMD != nullptr) {
            glGenPerfMonitorsAMD(n, monitors);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenPerfMonitorsAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenPerfMonitorsAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenPerfMonitorsAMD\n");
        return false;
    }
}

bool callGlGenProgramPipelinesEXT(Stack* stack, bool pushReturn) {
    uint32_t* pipelines = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenProgramPipelinesEXT(%" PRId32 ", %p)\n", n, pipelines);
        if (glGenProgramPipelinesEXT != nullptr) {
            glGenProgramPipelinesEXT(n, pipelines);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenProgramPipelinesEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenProgramPipelinesEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenProgramPipelinesEXT\n");
        return false;
    }
}

bool callGlGenQueriesEXT(Stack* stack, bool pushReturn) {
    uint32_t* queries = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenQueriesEXT(%" PRId32 ", %p)\n", count, queries);
        if (glGenQueriesEXT != nullptr) {
            glGenQueriesEXT(count, queries);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenQueriesEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenQueriesEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenQueriesEXT\n");
        return false;
    }
}

bool callGlGenVertexArraysOES(Stack* stack, bool pushReturn) {
    uint32_t* arrays = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenVertexArraysOES(%" PRId32 ", %p)\n", count, arrays);
        if (glGenVertexArraysOES != nullptr) {
            glGenVertexArraysOES(count, arrays);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenVertexArraysOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenVertexArraysOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenVertexArraysOES\n");
        return false;
    }
}

bool callGlGetBufferPointervOES(Stack* stack, bool pushReturn) {
    void** params = stack->pop<void**>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetBufferPointervOES(%u, %u, %p)\n", target, pname, params);
        if (glGetBufferPointervOES != nullptr) {
            glGetBufferPointervOES(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetBufferPointervOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetBufferPointervOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetBufferPointervOES\n");
        return false;
    }
}

bool callGlGetDriverControlStringQCOM(Stack* stack, bool pushReturn) {
    char* driverControlString = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t driverControl = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetDriverControlStringQCOM(%" PRIu32 ", %" PRId32 ", %p, %p)\n",
                   driverControl, bufSize, length, driverControlString);
        if (glGetDriverControlStringQCOM != nullptr) {
            glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetDriverControlStringQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetDriverControlStringQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetDriverControlStringQCOM\n");
        return false;
    }
}

bool callGlGetDriverControlsQCOM(Stack* stack, bool pushReturn) {
    uint32_t* driverControls = stack->pop<uint32_t*>();
    int32_t size = stack->pop<int32_t>();
    int32_t* num = stack->pop<int32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glGetDriverControlsQCOM(%p, %" PRId32 ", %p)\n", num, size, driverControls);
        if (glGetDriverControlsQCOM != nullptr) {
            glGetDriverControlsQCOM(num, size, driverControls);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetDriverControlsQCOM returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetDriverControlsQCOM\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetDriverControlsQCOM\n");
        return false;
    }
}

bool callGlGetFenceivNV(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t fence = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFenceivNV(%" PRIu32 ", %u, %p)\n", fence, pname, params);
        if (glGetFenceivNV != nullptr) {
            glGetFenceivNV(fence, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFenceivNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFenceivNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFenceivNV\n");
        return false;
    }
}

bool callGlGetFirstPerfQueryIdINTEL(Stack* stack, bool pushReturn) {
    uint32_t* queryId = stack->pop<uint32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFirstPerfQueryIdINTEL(%p)\n", queryId);
        if (glGetFirstPerfQueryIdINTEL != nullptr) {
            glGetFirstPerfQueryIdINTEL(queryId);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFirstPerfQueryIdINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFirstPerfQueryIdINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFirstPerfQueryIdINTEL\n");
        return false;
    }
}

bool callGlGetFloatiVNV(Stack* stack, bool pushReturn) {
    float* data = stack->pop<float*>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFloati_vNV(%u, %" PRIu32 ", %p)\n", target, index, data);
        if (glGetFloati_vNV != nullptr) {
            glGetFloati_vNV(target, index, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFloati_vNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFloati_vNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFloati_vNV\n");
        return false;
    }
}

bool callGlGetGraphicsResetStatusEXT(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glGetGraphicsResetStatusEXT()\n");
        if (glGetGraphicsResetStatusEXT != nullptr) {
            GLenum return_value = glGetGraphicsResetStatusEXT();
            GAPID_INFO("Returned: %u\n", return_value);
            if (pushReturn) {
                stack->push<GLenum>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetGraphicsResetStatusEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetGraphicsResetStatusEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetGraphicsResetStatusEXT\n");
        return false;
    }
}

bool callGlGetGraphicsResetStatusKHR(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glGetGraphicsResetStatusKHR()\n");
        if (glGetGraphicsResetStatusKHR != nullptr) {
            GLenum return_value = glGetGraphicsResetStatusKHR();
            GAPID_INFO("Returned: %u\n", return_value);
            if (pushReturn) {
                stack->push<GLenum>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetGraphicsResetStatusKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetGraphicsResetStatusKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetGraphicsResetStatusKHR\n");
        return false;
    }
}

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

bool callGlGetInteger64vAPPLE(Stack* stack, bool pushReturn) {
    int64_t* params = stack->pop<int64_t*>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetInteger64vAPPLE(%u, %p)\n", pname, params);
        if (glGetInteger64vAPPLE != nullptr) {
            glGetInteger64vAPPLE(pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetInteger64vAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetInteger64vAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetInteger64vAPPLE\n");
        return false;
    }
}

bool callGlGetIntegeriVEXT(Stack* stack, bool pushReturn) {
    int32_t* data = stack->pop<int32_t*>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetIntegeri_vEXT(%u, %" PRIu32 ", %p)\n", target, index, data);
        if (glGetIntegeri_vEXT != nullptr) {
            glGetIntegeri_vEXT(target, index, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetIntegeri_vEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetIntegeri_vEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetIntegeri_vEXT\n");
        return false;
    }
}

bool callGlGetInternalformatSampleivNV(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    int32_t samples = stack->pop<int32_t>();
    GLenum internalformat = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetInternalformatSampleivNV(%u, %u, %" PRId32 ", %u, %" PRId32 ", %p)\n",
                   target, internalformat, samples, pname, bufSize, params);
        if (glGetInternalformatSampleivNV != nullptr) {
            glGetInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetInternalformatSampleivNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetInternalformatSampleivNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetInternalformatSampleivNV\n");
        return false;
    }
}

bool callGlGetNextPerfQueryIdINTEL(Stack* stack, bool pushReturn) {
    uint32_t* nextQueryId = stack->pop<uint32_t*>();
    uint32_t queryId = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetNextPerfQueryIdINTEL(%" PRIu32 ", %p)\n", queryId, nextQueryId);
        if (glGetNextPerfQueryIdINTEL != nullptr) {
            glGetNextPerfQueryIdINTEL(queryId, nextQueryId);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetNextPerfQueryIdINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetNextPerfQueryIdINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetNextPerfQueryIdINTEL\n");
        return false;
    }
}

bool callGlGetObjectLabelEXT(Stack* stack, bool pushReturn) {
    char* label = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t object = stack->pop<uint32_t>();
    GLenum type = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetObjectLabelEXT(%u, %" PRIu32 ", %" PRId32 ", %p, %p)\n", type, object,
                   bufSize, length, label);
        if (glGetObjectLabelEXT != nullptr) {
            glGetObjectLabelEXT(type, object, bufSize, length, label);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetObjectLabelEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetObjectLabelEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetObjectLabelEXT\n");
        return false;
    }
}

bool callGlGetPathCommandsNV(Stack* stack, bool pushReturn) {
    uint8_t* commands = stack->pop<uint8_t*>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathCommandsNV(%" PRIu32 ", %p)\n", path, commands);
        if (glGetPathCommandsNV != nullptr) {
            glGetPathCommandsNV(path, commands);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathCommandsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathCommandsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathCommandsNV\n");
        return false;
    }
}

bool callGlGetPathCoordsNV(Stack* stack, bool pushReturn) {
    float* coords = stack->pop<float*>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathCoordsNV(%" PRIu32 ", %p)\n", path, coords);
        if (glGetPathCoordsNV != nullptr) {
            glGetPathCoordsNV(path, coords);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathCoordsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathCoordsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathCoordsNV\n");
        return false;
    }
}

bool callGlGetPathDashArrayNV(Stack* stack, bool pushReturn) {
    float* dashArray = stack->pop<float*>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathDashArrayNV(%" PRIu32 ", %p)\n", path, dashArray);
        if (glGetPathDashArrayNV != nullptr) {
            glGetPathDashArrayNV(path, dashArray);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathDashArrayNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathDashArrayNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathDashArrayNV\n");
        return false;
    }
}

bool callGlGetPathLengthNV(Stack* stack, bool pushReturn) {
    int32_t numSegments = stack->pop<int32_t>();
    int32_t startSegment = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathLengthNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ")\n", path, startSegment,
                   numSegments);
        if (glGetPathLengthNV != nullptr) {
            float return_value = glGetPathLengthNV(path, startSegment, numSegments);
            GAPID_INFO("Returned: %f\n", return_value);
            if (pushReturn) {
                stack->push<float>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathLengthNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathLengthNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathLengthNV\n");
        return false;
    }
}

bool callGlGetPathMetricRangeNV(Stack* stack, bool pushReturn) {
    float* metrics = stack->pop<float*>();
    int32_t stride = stack->pop<int32_t>();
    int32_t numPaths = stack->pop<int32_t>();
    uint32_t firstPathName = stack->pop<uint32_t>();
    GLbitfield metricQueryMask = stack->pop<GLbitfield>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathMetricRangeNV(%u, %" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n",
                   metricQueryMask, firstPathName, numPaths, stride, metrics);
        if (glGetPathMetricRangeNV != nullptr) {
            glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathMetricRangeNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathMetricRangeNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathMetricRangeNV\n");
        return false;
    }
}

bool callGlGetPathMetricsNV(Stack* stack, bool pushReturn) {
    float* metrics = stack->pop<float*>();
    int32_t stride = stack->pop<int32_t>();
    uint32_t pathBase = stack->pop<uint32_t>();
    void* paths = stack->pop<void*>();
    GLenum pathNameType = stack->pop<GLenum>();
    int32_t numPaths = stack->pop<int32_t>();
    GLbitfield metricQueryMask = stack->pop<GLbitfield>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathMetricsNV(%u, %" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32 ", %p)\n",
                   metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
        if (glGetPathMetricsNV != nullptr) {
            glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride,
                               metrics);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathMetricsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathMetricsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathMetricsNV\n");
        return false;
    }
}

bool callGlGetPathParameterfvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathParameterfvNV(%" PRIu32 ", %u, %p)\n", path, pname, value);
        if (glGetPathParameterfvNV != nullptr) {
            glGetPathParameterfvNV(path, pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathParameterfvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathParameterfvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathParameterfvNV\n");
        return false;
    }
}

bool callGlGetPathParameterivNV(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPathParameterivNV(%" PRIu32 ", %u, %p)\n", path, pname, value);
        if (glGetPathParameterivNV != nullptr) {
            glGetPathParameterivNV(path, pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPathParameterivNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPathParameterivNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPathParameterivNV\n");
        return false;
    }
}

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

bool callGlGetPerfCounterInfoINTEL(Stack* stack, bool pushReturn) {
    uint64_t* rawCounterMaxValue = stack->pop<uint64_t*>();
    uint32_t* counterDataTypeEnum = stack->pop<uint32_t*>();
    uint32_t* counterTypeEnum = stack->pop<uint32_t*>();
    uint32_t* counterDataSize = stack->pop<uint32_t*>();
    uint32_t* counterOffset = stack->pop<uint32_t*>();
    char* counterDesc = stack->pop<char*>();
    uint32_t counterDescLength = stack->pop<uint32_t>();
    char* counterName = stack->pop<char*>();
    uint32_t counterNameLength = stack->pop<uint32_t>();
    uint32_t counterId = stack->pop<uint32_t>();
    uint32_t queryId = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfCounterInfoINTEL(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %p, %" PRIu32
                   ", %p, %p, %p, %p, %p, %p)\n",
                   queryId, counterId, counterNameLength, counterName, counterDescLength,
                   counterDesc, counterOffset, counterDataSize, counterTypeEnum,
                   counterDataTypeEnum, rawCounterMaxValue);
        if (glGetPerfCounterInfoINTEL != nullptr) {
            glGetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName,
                                      counterDescLength, counterDesc, counterOffset,
                                      counterDataSize, counterTypeEnum, counterDataTypeEnum,
                                      rawCounterMaxValue);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfCounterInfoINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPerfCounterInfoINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfCounterInfoINTEL\n");
        return false;
    }
}

bool callGlGetPerfMonitorCounterDataAMD(Stack* stack, bool pushReturn) {
    int32_t* bytesWritten = stack->pop<int32_t*>();
    uint32_t* data = stack->pop<uint32_t*>();
    int32_t dataSize = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t monitor = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfMonitorCounterDataAMD(%" PRIu32 ", %u, %" PRId32 ", %p, %p)\n",
                   monitor, pname, dataSize, data, bytesWritten);
        if (glGetPerfMonitorCounterDataAMD != nullptr) {
            glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfMonitorCounterDataAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glGetPerfMonitorCounterDataAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfMonitorCounterDataAMD\n");
        return false;
    }
}

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

bool callGlGetPerfMonitorCounterStringAMD(Stack* stack, bool pushReturn) {
    char* counterString = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t counter = stack->pop<uint32_t>();
    uint32_t group = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfMonitorCounterStringAMD(%" PRIu32 ", %" PRIu32 ", %" PRId32
                   ", %p, %p)\n",
                   group, counter, bufSize, length, counterString);
        if (glGetPerfMonitorCounterStringAMD != nullptr) {
            glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfMonitorCounterStringAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glGetPerfMonitorCounterStringAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfMonitorCounterStringAMD\n");
        return false;
    }
}

bool callGlGetPerfMonitorCountersAMD(Stack* stack, bool pushReturn) {
    uint32_t* counters = stack->pop<uint32_t*>();
    int32_t counterSize = stack->pop<int32_t>();
    int32_t* maxActiveCounters = stack->pop<int32_t*>();
    int32_t* numCounters = stack->pop<int32_t*>();
    uint32_t group = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfMonitorCountersAMD(%" PRIu32 ", %p, %p, %" PRId32 ", %p)\n", group,
                   numCounters, maxActiveCounters, counterSize, counters);
        if (glGetPerfMonitorCountersAMD != nullptr) {
            glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize,
                                        counters);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfMonitorCountersAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorCountersAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfMonitorCountersAMD\n");
        return false;
    }
}

bool callGlGetPerfMonitorGroupStringAMD(Stack* stack, bool pushReturn) {
    char* groupString = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t group = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfMonitorGroupStringAMD(%" PRIu32 ", %" PRId32 ", %p, %p)\n", group,
                   bufSize, length, groupString);
        if (glGetPerfMonitorGroupStringAMD != nullptr) {
            glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfMonitorGroupStringAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glGetPerfMonitorGroupStringAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfMonitorGroupStringAMD\n");
        return false;
    }
}

bool callGlGetPerfMonitorGroupsAMD(Stack* stack, bool pushReturn) {
    uint32_t* groups = stack->pop<uint32_t*>();
    int32_t groupsSize = stack->pop<int32_t>();
    int32_t* numGroups = stack->pop<int32_t*>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfMonitorGroupsAMD(%p, %" PRId32 ", %p)\n", numGroups, groupsSize,
                   groups);
        if (glGetPerfMonitorGroupsAMD != nullptr) {
            glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfMonitorGroupsAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPerfMonitorGroupsAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfMonitorGroupsAMD\n");
        return false;
    }
}

bool callGlGetPerfQueryDataINTEL(Stack* stack, bool pushReturn) {
    uint32_t* bytesWritten = stack->pop<uint32_t*>();
    void* data = stack->pop<void*>();
    int32_t dataSize = stack->pop<int32_t>();
    uint32_t flag = stack->pop<uint32_t>();
    uint32_t queryHandle = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfQueryDataINTEL(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)\n",
                   queryHandle, flag, dataSize, data, bytesWritten);
        if (glGetPerfQueryDataINTEL != nullptr) {
            glGetPerfQueryDataINTEL(queryHandle, flag, dataSize, data, bytesWritten);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfQueryDataINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPerfQueryDataINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfQueryDataINTEL\n");
        return false;
    }
}

bool callGlGetPerfQueryIdByNameINTEL(Stack* stack, bool pushReturn) {
    uint32_t* queryId = stack->pop<uint32_t*>();
    char* queryName = stack->pop<char*>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfQueryIdByNameINTEL(%p, %p)\n", queryName, queryId);
        if (glGetPerfQueryIdByNameINTEL != nullptr) {
            glGetPerfQueryIdByNameINTEL(queryName, queryId);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfQueryIdByNameINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPerfQueryIdByNameINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfQueryIdByNameINTEL\n");
        return false;
    }
}

bool callGlGetPerfQueryInfoINTEL(Stack* stack, bool pushReturn) {
    uint32_t* capsMask = stack->pop<uint32_t*>();
    uint32_t* noInstances = stack->pop<uint32_t*>();
    uint32_t* noCounters = stack->pop<uint32_t*>();
    uint32_t* dataSize = stack->pop<uint32_t*>();
    char* queryName = stack->pop<char*>();
    uint32_t queryNameLength = stack->pop<uint32_t>();
    uint32_t queryId = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetPerfQueryInfoINTEL(%" PRIu32 ", %" PRIu32 ", %p, %p, %p, %p, %p)\n",
                   queryId, queryNameLength, queryName, dataSize, noCounters, noInstances,
                   capsMask);
        if (glGetPerfQueryInfoINTEL != nullptr) {
            glGetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters,
                                    noInstances, capsMask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetPerfQueryInfoINTEL returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetPerfQueryInfoINTEL\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetPerfQueryInfoINTEL\n");
        return false;
    }
}

bool callGlGetProgramBinaryOES(Stack* stack, bool pushReturn) {
    void* binary = stack->pop<void*>();
    GLenum* binary_format = stack->pop<GLenum*>();
    int32_t* bytes_written = stack->pop<int32_t*>();
    int32_t buffer_size = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramBinaryOES(%" PRIu32 ", %" PRId32 ", %p, %p, %p)\n", program,
                   buffer_size, bytes_written, binary_format, binary);
        if (glGetProgramBinaryOES != nullptr) {
            glGetProgramBinaryOES(program, buffer_size, bytes_written, binary_format, binary);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramBinaryOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramBinaryOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramBinaryOES\n");
        return false;
    }
}

bool callGlGetProgramPipelineInfoLogEXT(Stack* stack, bool pushReturn) {
    char* infoLog = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramPipelineInfoLogEXT(%" PRIu32 ", %" PRId32 ", %p, %p)\n", pipeline,
                   bufSize, length, infoLog);
        if (glGetProgramPipelineInfoLogEXT != nullptr) {
            glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramPipelineInfoLogEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glGetProgramPipelineInfoLogEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramPipelineInfoLogEXT\n");
        return false;
    }
}

bool callGlGetProgramPipelineivEXT(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramPipelineivEXT(%" PRIu32 ", %u, %p)\n", pipeline, pname, params);
        if (glGetProgramPipelineivEXT != nullptr) {
            glGetProgramPipelineivEXT(pipeline, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramPipelineivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramPipelineivEXT\n");
        return false;
    }
}

bool callGlGetProgramResourcefvNV(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    GLenum* props = stack->pop<GLenum*>();
    int32_t propCount = stack->pop<int32_t>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum programInterface = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramResourcefvNV(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32
                   ", %p, %" PRId32 ", %p, %p)\n",
                   program, programInterface, index, propCount, props, bufSize, length, params);
        if (glGetProgramResourcefvNV != nullptr) {
            glGetProgramResourcefvNV(program, programInterface, index, propCount, props, bufSize,
                                     length, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramResourcefvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramResourcefvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramResourcefvNV\n");
        return false;
    }
}

bool callGlGetQueryObjecti64vEXT(Stack* stack, bool pushReturn) {
    int64_t* value = stack->pop<int64_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryObjecti64vEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
        if (glGetQueryObjecti64vEXT != nullptr) {
            glGetQueryObjecti64vEXT(query, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryObjecti64vEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryObjecti64vEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryObjecti64vEXT\n");
        return false;
    }
}

bool callGlGetQueryObjectivEXT(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryObjectivEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
        if (glGetQueryObjectivEXT != nullptr) {
            glGetQueryObjectivEXT(query, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryObjectivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryObjectivEXT\n");
        return false;
    }
}

bool callGlGetQueryObjectui64vEXT(Stack* stack, bool pushReturn) {
    uint64_t* value = stack->pop<uint64_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryObjectui64vEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
        if (glGetQueryObjectui64vEXT != nullptr) {
            glGetQueryObjectui64vEXT(query, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryObjectui64vEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectui64vEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryObjectui64vEXT\n");
        return false;
    }
}

bool callGlGetQueryObjectuivEXT(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryObjectuivEXT(%" PRIu32 ", %u, %p)\n", query, parameter, value);
        if (glGetQueryObjectuivEXT != nullptr) {
            glGetQueryObjectuivEXT(query, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryObjectuivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryObjectuivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryObjectuivEXT\n");
        return false;
    }
}

bool callGlGetQueryivEXT(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetQueryivEXT(%u, %u, %p)\n", target, parameter, value);
        if (glGetQueryivEXT != nullptr) {
            glGetQueryivEXT(target, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetQueryivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetQueryivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetQueryivEXT\n");
        return false;
    }
}

bool callGlGetSamplerParameterIivOES(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSamplerParameterIivOES(%" PRIu32 ", %u, %p)\n", sampler, pname, params);
        if (glGetSamplerParameterIivOES != nullptr) {
            glGetSamplerParameterIivOES(sampler, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSamplerParameterIivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSamplerParameterIivOES\n");
        return false;
    }
}

bool callGlGetSamplerParameterIuivOES(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSamplerParameterIuivOES(%" PRIu32 ", %u, %p)\n", sampler, pname, params);
        if (glGetSamplerParameterIuivOES != nullptr) {
            glGetSamplerParameterIuivOES(sampler, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSamplerParameterIuivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterIuivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSamplerParameterIuivOES\n");
        return false;
    }
}

bool callGlGetSyncivAPPLE(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSyncivAPPLE(%" PRIu64 ", %u, %" PRId32 ", %p, %p)\n", sync, pname, bufSize,
                   length, values);
        if (glGetSyncivAPPLE != nullptr) {
            glGetSyncivAPPLE(sync, pname, bufSize, length, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSyncivAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSyncivAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSyncivAPPLE\n");
        return false;
    }
}

bool callGlGetTexParameterIivOES(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexParameterIivOES(%u, %u, %p)\n", target, pname, params);
        if (glGetTexParameterIivOES != nullptr) {
            glGetTexParameterIivOES(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexParameterIivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexParameterIivOES\n");
        return false;
    }
}

bool callGlGetTexParameterIuivOES(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexParameterIuivOES(%u, %u, %p)\n", target, pname, params);
        if (glGetTexParameterIuivOES != nullptr) {
            glGetTexParameterIuivOES(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexParameterIuivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexParameterIuivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexParameterIuivOES\n");
        return false;
    }
}

bool callGlGetTextureHandleNV(Stack* stack, bool pushReturn) {
    uint32_t texture = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTextureHandleNV(%" PRIu32 ")\n", texture);
        if (glGetTextureHandleNV != nullptr) {
            uint64_t return_value = glGetTextureHandleNV(texture);
            GAPID_INFO("Returned: %" PRIu64 "\n", return_value);
            if (pushReturn) {
                stack->push<uint64_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTextureHandleNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTextureHandleNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTextureHandleNV\n");
        return false;
    }
}

bool callGlGetTextureSamplerHandleNV(Stack* stack, bool pushReturn) {
    uint32_t sampler = stack->pop<uint32_t>();
    uint32_t texture = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTextureSamplerHandleNV(%" PRIu32 ", %" PRIu32 ")\n", texture, sampler);
        if (glGetTextureSamplerHandleNV != nullptr) {
            uint64_t return_value = glGetTextureSamplerHandleNV(texture, sampler);
            GAPID_INFO("Returned: %" PRIu64 "\n", return_value);
            if (pushReturn) {
                stack->push<uint64_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTextureSamplerHandleNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTextureSamplerHandleNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTextureSamplerHandleNV\n");
        return false;
    }
}

bool callGlGetTranslatedShaderSourceANGLE(Stack* stack, bool pushReturn) {
    char* source = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufsize = stack->pop<int32_t>();
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTranslatedShaderSourceANGLE(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader,
                   bufsize, length, source);
        if (glGetTranslatedShaderSourceANGLE != nullptr) {
            glGetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTranslatedShaderSourceANGLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glGetTranslatedShaderSourceANGLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTranslatedShaderSourceANGLE\n");
        return false;
    }
}

bool callGlGetnUniformfvEXT(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    int32_t bufSize = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetnUniformfvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, bufSize, params);
        if (glGetnUniformfvEXT != nullptr) {
            glGetnUniformfvEXT(program, location, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetnUniformfvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetnUniformfvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetnUniformfvEXT\n");
        return false;
    }
}

bool callGlGetnUniformfvKHR(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    int32_t bufSize = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetnUniformfvKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, bufSize, params);
        if (glGetnUniformfvKHR != nullptr) {
            glGetnUniformfvKHR(program, location, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetnUniformfvKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetnUniformfvKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetnUniformfvKHR\n");
        return false;
    }
}

bool callGlGetnUniformivEXT(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetnUniformivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, bufSize, params);
        if (glGetnUniformivEXT != nullptr) {
            glGetnUniformivEXT(program, location, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetnUniformivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetnUniformivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetnUniformivEXT\n");
        return false;
    }
}

bool callGlGetnUniformivKHR(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetnUniformivKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, bufSize, params);
        if (glGetnUniformivKHR != nullptr) {
            glGetnUniformivKHR(program, location, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetnUniformivKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetnUniformivKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetnUniformivKHR\n");
        return false;
    }
}

bool callGlGetnUniformuivKHR(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetnUniformuivKHR(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, bufSize, params);
        if (glGetnUniformuivKHR != nullptr) {
            glGetnUniformuivKHR(program, location, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetnUniformuivKHR returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetnUniformuivKHR\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetnUniformuivKHR\n");
        return false;
    }
}

bool callGlInsertEventMarkerEXT(Stack* stack, bool pushReturn) {
    char* marker = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glInsertEventMarkerEXT(%" PRId32 ", %p)\n", length, marker);
        if (glInsertEventMarkerEXT != nullptr) {
            glInsertEventMarkerEXT(length, marker);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glInsertEventMarkerEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glInsertEventMarkerEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glInsertEventMarkerEXT\n");
        return false;
    }
}

bool callGlInterpolatePathsNV(Stack* stack, bool pushReturn) {
    float weight = stack->pop<float>();
    uint32_t pathB = stack->pop<uint32_t>();
    uint32_t pathA = stack->pop<uint32_t>();
    uint32_t resultPath = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glInterpolatePathsNV(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %f)\n", resultPath,
                   pathA, pathB, weight);
        if (glInterpolatePathsNV != nullptr) {
            glInterpolatePathsNV(resultPath, pathA, pathB, weight);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glInterpolatePathsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glInterpolatePathsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glInterpolatePathsNV\n");
        return false;
    }
}

bool callGlIsEnablediOES(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glIsEnablediOES(%u, %" PRIu32 ")\n", target, index);
        if (glIsEnablediOES != nullptr) {
            bool return_value = glIsEnablediOES(target, index);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsEnablediOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsEnablediOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsEnablediOES\n");
        return false;
    }
}

bool callGlIsEnablediNV(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glIsEnablediNV(%u, %" PRIu32 ")\n", target, index);
        if (glIsEnablediNV != nullptr) {
            bool return_value = glIsEnablediNV(target, index);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsEnablediNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsEnablediNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsEnablediNV\n");
        return false;
    }
}

bool callGlIsFenceNV(Stack* stack, bool pushReturn) {
    uint32_t fence = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsFenceNV(%" PRIu32 ")\n", fence);
        if (glIsFenceNV != nullptr) {
            bool return_value = glIsFenceNV(fence);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsFenceNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsFenceNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsFenceNV\n");
        return false;
    }
}

bool callGlIsImageHandleResidentNV(Stack* stack, bool pushReturn) {
    uint64_t handle = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsImageHandleResidentNV(%" PRIu64 ")\n", handle);
        if (glIsImageHandleResidentNV != nullptr) {
            bool return_value = glIsImageHandleResidentNV(handle);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsImageHandleResidentNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsImageHandleResidentNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsImageHandleResidentNV\n");
        return false;
    }
}

bool callGlIsPathNV(Stack* stack, bool pushReturn) {
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsPathNV(%" PRIu32 ")\n", path);
        if (glIsPathNV != nullptr) {
            bool return_value = glIsPathNV(path);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsPathNV\n");
        return false;
    }
}

bool callGlIsPointInFillPathNV(Stack* stack, bool pushReturn) {
    float y = stack->pop<float>();
    float x = stack->pop<float>();
    uint32_t mask = stack->pop<uint32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsPointInFillPathNV(%" PRIu32 ", %" PRIu32 ", %f, %f)\n", path, mask, x, y);
        if (glIsPointInFillPathNV != nullptr) {
            bool return_value = glIsPointInFillPathNV(path, mask, x, y);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsPointInFillPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsPointInFillPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsPointInFillPathNV\n");
        return false;
    }
}

bool callGlIsPointInStrokePathNV(Stack* stack, bool pushReturn) {
    float y = stack->pop<float>();
    float x = stack->pop<float>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsPointInStrokePathNV(%" PRIu32 ", %f, %f)\n", path, x, y);
        if (glIsPointInStrokePathNV != nullptr) {
            bool return_value = glIsPointInStrokePathNV(path, x, y);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsPointInStrokePathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsPointInStrokePathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsPointInStrokePathNV\n");
        return false;
    }
}

bool callGlIsProgramPipelineEXT(Stack* stack, bool pushReturn) {
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsProgramPipelineEXT(%" PRIu32 ")\n", pipeline);
        if (glIsProgramPipelineEXT != nullptr) {
            bool return_value = glIsProgramPipelineEXT(pipeline);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsProgramPipelineEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsProgramPipelineEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsProgramPipelineEXT\n");
        return false;
    }
}

bool callGlIsQueryEXT(Stack* stack, bool pushReturn) {
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsQueryEXT(%" PRIu32 ")\n", query);
        if (glIsQueryEXT != nullptr) {
            bool return_value = glIsQueryEXT(query);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsQueryEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsQueryEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsQueryEXT\n");
        return false;
    }
}

bool callGlIsSyncAPPLE(Stack* stack, bool pushReturn) {
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsSyncAPPLE(%" PRIu64 ")\n", sync);
        if (glIsSyncAPPLE != nullptr) {
            bool return_value = glIsSyncAPPLE(sync);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsSyncAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsSyncAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsSyncAPPLE\n");
        return false;
    }
}

bool callGlIsTextureHandleResidentNV(Stack* stack, bool pushReturn) {
    uint64_t handle = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsTextureHandleResidentNV(%" PRIu64 ")\n", handle);
        if (glIsTextureHandleResidentNV != nullptr) {
            bool return_value = glIsTextureHandleResidentNV(handle);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsTextureHandleResidentNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsTextureHandleResidentNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsTextureHandleResidentNV\n");
        return false;
    }
}

bool callGlIsVertexArrayOES(Stack* stack, bool pushReturn) {
    uint32_t array = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsVertexArrayOES(%" PRIu32 ")\n", array);
        if (glIsVertexArrayOES != nullptr) {
            bool return_value = glIsVertexArrayOES(array);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsVertexArrayOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsVertexArrayOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsVertexArrayOES\n");
        return false;
    }
}

bool callGlLabelObjectEXT(Stack* stack, bool pushReturn) {
    char* label = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    uint32_t object = stack->pop<uint32_t>();
    GLenum type = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glLabelObjectEXT(%u, %" PRIu32 ", %" PRId32 ", %p)\n", type, object, length,
                   label);
        if (glLabelObjectEXT != nullptr) {
            glLabelObjectEXT(type, object, length, label);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glLabelObjectEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glLabelObjectEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glLabelObjectEXT\n");
        return false;
    }
}

bool callGlMakeImageHandleNonResidentNV(Stack* stack, bool pushReturn) {
    uint64_t handle = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glMakeImageHandleNonResidentNV(%" PRIu64 ")\n", handle);
        if (glMakeImageHandleNonResidentNV != nullptr) {
            glMakeImageHandleNonResidentNV(handle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMakeImageHandleNonResidentNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glMakeImageHandleNonResidentNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMakeImageHandleNonResidentNV\n");
        return false;
    }
}

bool callGlMakeImageHandleResidentNV(Stack* stack, bool pushReturn) {
    GLenum access = stack->pop<GLenum>();
    uint64_t handle = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glMakeImageHandleResidentNV(%" PRIu64 ", %u)\n", handle, access);
        if (glMakeImageHandleResidentNV != nullptr) {
            glMakeImageHandleResidentNV(handle, access);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMakeImageHandleResidentNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMakeImageHandleResidentNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMakeImageHandleResidentNV\n");
        return false;
    }
}

bool callGlMakeTextureHandleNonResidentNV(Stack* stack, bool pushReturn) {
    uint64_t handle = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glMakeTextureHandleNonResidentNV(%" PRIu64 ")\n", handle);
        if (glMakeTextureHandleNonResidentNV != nullptr) {
            glMakeTextureHandleNonResidentNV(handle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMakeTextureHandleNonResidentNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glMakeTextureHandleNonResidentNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMakeTextureHandleNonResidentNV\n");
        return false;
    }
}

bool callGlMakeTextureHandleResidentNV(Stack* stack, bool pushReturn) {
    uint64_t handle = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glMakeTextureHandleResidentNV(%" PRIu64 ")\n", handle);
        if (glMakeTextureHandleResidentNV != nullptr) {
            glMakeTextureHandleResidentNV(handle);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMakeTextureHandleResidentNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMakeTextureHandleResidentNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMakeTextureHandleResidentNV\n");
        return false;
    }
}

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

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

bool callGlMatrixLoad3x2fNV(Stack* stack, bool pushReturn) {
    float* m = stack->pop<float*>();
    GLenum matrixMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMatrixLoad3x2fNV(%u, %p)\n", matrixMode, m);
        if (glMatrixLoad3x2fNV != nullptr) {
            glMatrixLoad3x2fNV(matrixMode, m);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMatrixLoad3x2fNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMatrixLoad3x2fNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMatrixLoad3x2fNV\n");
        return false;
    }
}

bool callGlMatrixLoad3x3fNV(Stack* stack, bool pushReturn) {
    float* m = stack->pop<float*>();
    GLenum matrixMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMatrixLoad3x3fNV(%u, %p)\n", matrixMode, m);
        if (glMatrixLoad3x3fNV != nullptr) {
            glMatrixLoad3x3fNV(matrixMode, m);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMatrixLoad3x3fNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMatrixLoad3x3fNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMatrixLoad3x3fNV\n");
        return false;
    }
}

bool callGlMatrixLoadTranspose3x3fNV(Stack* stack, bool pushReturn) {
    float* m = stack->pop<float*>();
    GLenum matrixMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMatrixLoadTranspose3x3fNV(%u, %p)\n", matrixMode, m);
        if (glMatrixLoadTranspose3x3fNV != nullptr) {
            glMatrixLoadTranspose3x3fNV(matrixMode, m);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMatrixLoadTranspose3x3fNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMatrixLoadTranspose3x3fNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMatrixLoadTranspose3x3fNV\n");
        return false;
    }
}

bool callGlMatrixMult3x2fNV(Stack* stack, bool pushReturn) {
    float* m = stack->pop<float*>();
    GLenum matrixMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMatrixMult3x2fNV(%u, %p)\n", matrixMode, m);
        if (glMatrixMult3x2fNV != nullptr) {
            glMatrixMult3x2fNV(matrixMode, m);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMatrixMult3x2fNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMatrixMult3x2fNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMatrixMult3x2fNV\n");
        return false;
    }
}

bool callGlMatrixMult3x3fNV(Stack* stack, bool pushReturn) {
    float* m = stack->pop<float*>();
    GLenum matrixMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMatrixMult3x3fNV(%u, %p)\n", matrixMode, m);
        if (glMatrixMult3x3fNV != nullptr) {
            glMatrixMult3x3fNV(matrixMode, m);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMatrixMult3x3fNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMatrixMult3x3fNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMatrixMult3x3fNV\n");
        return false;
    }
}

bool callGlMatrixMultTranspose3x3fNV(Stack* stack, bool pushReturn) {
    float* m = stack->pop<float*>();
    GLenum matrixMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMatrixMultTranspose3x3fNV(%u, %p)\n", matrixMode, m);
        if (glMatrixMultTranspose3x3fNV != nullptr) {
            glMatrixMultTranspose3x3fNV(matrixMode, m);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMatrixMultTranspose3x3fNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMatrixMultTranspose3x3fNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMatrixMultTranspose3x3fNV\n");
        return false;
    }
}

bool callGlMultiDrawArraysEXT(Stack* stack, bool pushReturn) {
    int32_t primcount = stack->pop<int32_t>();
    int32_t* count = stack->pop<int32_t*>();
    int32_t* first = stack->pop<int32_t*>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMultiDrawArraysEXT(%u, %p, %p, %" PRId32 ")\n", mode, first, count,
                   primcount);
        if (glMultiDrawArraysEXT != nullptr) {
            glMultiDrawArraysEXT(mode, first, count, primcount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMultiDrawArraysEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMultiDrawArraysEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMultiDrawArraysEXT\n");
        return false;
    }
}

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

bool callGlMultiDrawElementsBaseVertexEXT(Stack* stack, bool pushReturn) {
    int32_t* basevertex = stack->pop<int32_t*>();
    int32_t primcount = stack->pop<int32_t>();
    void** indices = stack->pop<void**>();
    GLenum type = stack->pop<GLenum>();
    int32_t* count = stack->pop<int32_t*>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMultiDrawElementsBaseVertexEXT(%u, %p, %u, %p, %" PRId32 ", %p)\n", mode,
                   count, type, indices, primcount, basevertex);
        if (glMultiDrawElementsBaseVertexEXT != nullptr) {
            glMultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMultiDrawElementsBaseVertexEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glMultiDrawElementsBaseVertexEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMultiDrawElementsBaseVertexEXT\n");
        return false;
    }
}

bool callGlMultiDrawElementsBaseVertexOES(Stack* stack, bool pushReturn) {
    int32_t* basevertex = stack->pop<int32_t*>();
    int32_t primcount = stack->pop<int32_t>();
    void** indices = stack->pop<void**>();
    GLenum type = stack->pop<GLenum>();
    int32_t* count = stack->pop<int32_t*>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMultiDrawElementsBaseVertexOES(%u, %p, %u, %p, %" PRId32 ", %p)\n", mode,
                   count, type, indices, primcount, basevertex);
        if (glMultiDrawElementsBaseVertexOES != nullptr) {
            glMultiDrawElementsBaseVertexOES(mode, count, type, indices, primcount, basevertex);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMultiDrawElementsBaseVertexOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glMultiDrawElementsBaseVertexOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMultiDrawElementsBaseVertexOES\n");
        return false;
    }
}

bool callGlMultiDrawElementsEXT(Stack* stack, bool pushReturn) {
    int32_t primcount = stack->pop<int32_t>();
    void** indices = stack->pop<void**>();
    GLenum type = stack->pop<GLenum>();
    int32_t* count = stack->pop<int32_t*>();
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glMultiDrawElementsEXT(%u, %p, %u, %p, %" PRId32 ")\n", mode, count, type,
                   indices, primcount);
        if (glMultiDrawElementsEXT != nullptr) {
            glMultiDrawElementsEXT(mode, count, type, indices, primcount);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMultiDrawElementsEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMultiDrawElementsEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMultiDrawElementsEXT\n");
        return false;
    }
}

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

bool callGlPatchParameteriOES(Stack* stack, bool pushReturn) {
    int32_t value = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glPatchParameteriOES(%u, %" PRId32 ")\n", pname, value);
        if (glPatchParameteriOES != nullptr) {
            glPatchParameteriOES(pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPatchParameteriOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPatchParameteriOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPatchParameteriOES\n");
        return false;
    }
}

bool callGlPathCommandsNV(Stack* stack, bool pushReturn) {
    void* coords = stack->pop<void*>();
    GLenum coordType = stack->pop<GLenum>();
    int32_t numCoords = stack->pop<int32_t>();
    uint8_t* commands = stack->pop<uint8_t*>();
    int32_t numCommands = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPathCommandsNV(%" PRIu32 ", %" PRId32 ", %p, %" PRId32 ", %u, %p)\n", path,
                   numCommands, commands, numCoords, coordType, coords);
        if (glPathCommandsNV != nullptr) {
            glPathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathCommandsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathCommandsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathCommandsNV\n");
        return false;
    }
}

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

bool callGlPathCoverDepthFuncNV(Stack* stack, bool pushReturn) {
    GLenum func = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glPathCoverDepthFuncNV(%u)\n", func);
        if (glPathCoverDepthFuncNV != nullptr) {
            glPathCoverDepthFuncNV(func);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathCoverDepthFuncNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathCoverDepthFuncNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathCoverDepthFuncNV\n");
        return false;
    }
}

bool callGlPathDashArrayNV(Stack* stack, bool pushReturn) {
    float* dashArray = stack->pop<float*>();
    int32_t dashCount = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPathDashArrayNV(%" PRIu32 ", %" PRId32 ", %p)\n", path, dashCount, dashArray);
        if (glPathDashArrayNV != nullptr) {
            glPathDashArrayNV(path, dashCount, dashArray);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathDashArrayNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathDashArrayNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathDashArrayNV\n");
        return false;
    }
}

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

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

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

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

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

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

bool callGlPathParameterfvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPathParameterfvNV(%" PRIu32 ", %u, %p)\n", path, pname, value);
        if (glPathParameterfvNV != nullptr) {
            glPathParameterfvNV(path, pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathParameterfvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathParameterfvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathParameterfvNV\n");
        return false;
    }
}

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

bool callGlPathParameterivNV(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPathParameterivNV(%" PRIu32 ", %u, %p)\n", path, pname, value);
        if (glPathParameterivNV != nullptr) {
            glPathParameterivNV(path, pname, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathParameterivNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathParameterivNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathParameterivNV\n");
        return false;
    }
}

bool callGlPathStencilDepthOffsetNV(Stack* stack, bool pushReturn) {
    float units = stack->pop<float>();
    float factor = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glPathStencilDepthOffsetNV(%f, %f)\n", factor, units);
        if (glPathStencilDepthOffsetNV != nullptr) {
            glPathStencilDepthOffsetNV(factor, units);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathStencilDepthOffsetNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathStencilDepthOffsetNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathStencilDepthOffsetNV\n");
        return false;
    }
}

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

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

bool callGlPathSubCommandsNV(Stack* stack, bool pushReturn) {
    void* coords = stack->pop<void*>();
    GLenum coordType = stack->pop<GLenum>();
    int32_t numCoords = stack->pop<int32_t>();
    uint8_t* commands = stack->pop<uint8_t*>();
    int32_t numCommands = stack->pop<int32_t>();
    int32_t commandsToDelete = stack->pop<int32_t>();
    int32_t commandStart = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPathSubCommandsNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %p, %" PRId32 ", %u, %p)\n",
                   path, commandStart, commandsToDelete, numCommands, commands, numCoords,
                   coordType, coords);
        if (glPathSubCommandsNV != nullptr) {
            glPathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands,
                                numCoords, coordType, coords);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPathSubCommandsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPathSubCommandsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPathSubCommandsNV\n");
        return false;
    }
}

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

bool callGlPointAlongPathNV(Stack* stack, bool pushReturn) {
    float* tangentY = stack->pop<float*>();
    float* tangentX = stack->pop<float*>();
    float* y = stack->pop<float*>();
    float* x = stack->pop<float*>();
    float distance = stack->pop<float>();
    int32_t numSegments = stack->pop<int32_t>();
    int32_t startSegment = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPointAlongPathNV(%" PRIu32 ", %" PRId32 ", %" PRId32
                   ", %f, %p, %p, %p, %p)\n",
                   path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
        if (glPointAlongPathNV != nullptr) {
            uint8_t return_value = glPointAlongPathNV(path, startSegment, numSegments, distance, x,
                                                      y, tangentX, tangentY);
            GAPID_INFO("Returned: %" PRIu8 "\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPointAlongPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPointAlongPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPointAlongPathNV\n");
        return false;
    }
}

bool callGlPolygonModeNV(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    GLenum face = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glPolygonModeNV(%u, %u)\n", face, mode);
        if (glPolygonModeNV != nullptr) {
            glPolygonModeNV(face, mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPolygonModeNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPolygonModeNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPolygonModeNV\n");
        return false;
    }
}

bool callGlPopGroupMarkerEXT(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glPopGroupMarkerEXT()\n");
        if (glPopGroupMarkerEXT != nullptr) {
            glPopGroupMarkerEXT();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPopGroupMarkerEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPopGroupMarkerEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPopGroupMarkerEXT\n");
        return false;
    }
}

bool callGlPrimitiveBoundingBoxOES(Stack* stack, bool pushReturn) {
    float maxW = stack->pop<float>();
    float maxZ = stack->pop<float>();
    float maxY = stack->pop<float>();
    float maxX = stack->pop<float>();
    float minW = stack->pop<float>();
    float minZ = stack->pop<float>();
    float minY = stack->pop<float>();
    float minX = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glPrimitiveBoundingBoxOES(%f, %f, %f, %f, %f, %f, %f, %f)\n", minX, minY, minZ,
                   minW, maxX, maxY, maxZ, maxW);
        if (glPrimitiveBoundingBoxOES != nullptr) {
            glPrimitiveBoundingBoxOES(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPrimitiveBoundingBoxOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPrimitiveBoundingBoxOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPrimitiveBoundingBoxOES\n");
        return false;
    }
}

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

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

bool callGlProgramPathFragmentInputGenNV(Stack* stack, bool pushReturn) {
    float* coeffs = stack->pop<float*>();
    int32_t components = stack->pop<int32_t>();
    GLenum genMode = stack->pop<GLenum>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramPathFragmentInputGenNV(%" PRIu32 ", %" PRId32 ", %u, %" PRId32
                   ", %p)\n",
                   program, location, genMode, components, coeffs);
        if (glProgramPathFragmentInputGenNV != nullptr) {
            glProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramPathFragmentInputGenNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramPathFragmentInputGenNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramPathFragmentInputGenNV\n");
        return false;
    }
}

bool callGlProgramUniform1fEXT(Stack* stack, bool pushReturn) {
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1fEXT(%" PRIu32 ", %" PRId32 ", %f)\n", program, location, v0);
        if (glProgramUniform1fEXT != nullptr) {
            glProgramUniform1fEXT(program, location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1fEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1fEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1fEXT\n");
        return false;
    }
}

bool callGlProgramUniform1fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform1fvEXT != nullptr) {
            glProgramUniform1fvEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1fvEXT\n");
        return false;
    }
}

bool callGlProgramUniform1iEXT(Stack* stack, bool pushReturn) {
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ")\n", program,
                   location, v0);
        if (glProgramUniform1iEXT != nullptr) {
            glProgramUniform1iEXT(program, location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1iEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1iEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1iEXT\n");
        return false;
    }
}

bool callGlProgramUniform1ivEXT(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform1ivEXT != nullptr) {
            glProgramUniform1ivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1ivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1ivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1ivEXT\n");
        return false;
    }
}

bool callGlProgramUniform1uiEXT(Stack* stack, bool pushReturn) {
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")\n", program,
                   location, v0);
        if (glProgramUniform1uiEXT != nullptr) {
            glProgramUniform1uiEXT(program, location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1uiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1uiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1uiEXT\n");
        return false;
    }
}

bool callGlProgramUniform1uivEXT(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform1uivEXT != nullptr) {
            glProgramUniform1uivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1uivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1uivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1uivEXT\n");
        return false;
    }
}

bool callGlProgramUniform2fEXT(Stack* stack, bool pushReturn) {
    float v1 = stack->pop<float>();
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2fEXT(%" PRIu32 ", %" PRId32 ", %f, %f)\n", program, location,
                   v0, v1);
        if (glProgramUniform2fEXT != nullptr) {
            glProgramUniform2fEXT(program, location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2fEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2fEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2fEXT\n");
        return false;
    }
}

bool callGlProgramUniform2fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform2fvEXT != nullptr) {
            glProgramUniform2fvEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2fvEXT\n");
        return false;
    }
}

bool callGlProgramUniform2iEXT(Stack* stack, bool pushReturn) {
    int32_t v1 = stack->pop<int32_t>();
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
                   program, location, v0, v1);
        if (glProgramUniform2iEXT != nullptr) {
            glProgramUniform2iEXT(program, location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2iEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2iEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2iEXT\n");
        return false;
    }
}

bool callGlProgramUniform2ivEXT(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform2ivEXT != nullptr) {
            glProgramUniform2ivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2ivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2ivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2ivEXT\n");
        return false;
    }
}

bool callGlProgramUniform2uiEXT(Stack* stack, bool pushReturn) {
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ")\n",
                   program, location, v0, v1);
        if (glProgramUniform2uiEXT != nullptr) {
            glProgramUniform2uiEXT(program, location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2uiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2uiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2uiEXT\n");
        return false;
    }
}

bool callGlProgramUniform2uivEXT(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform2uivEXT != nullptr) {
            glProgramUniform2uivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2uivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2uivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2uivEXT\n");
        return false;
    }
}

bool callGlProgramUniform3fEXT(Stack* stack, bool pushReturn) {
    float v2 = stack->pop<float>();
    float v1 = stack->pop<float>();
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3fEXT(%" PRIu32 ", %" PRId32 ", %f, %f, %f)\n", program,
                   location, v0, v1, v2);
        if (glProgramUniform3fEXT != nullptr) {
            glProgramUniform3fEXT(program, location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3fEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3fEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3fEXT\n");
        return false;
    }
}

bool callGlProgramUniform3fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform3fvEXT != nullptr) {
            glProgramUniform3fvEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3fvEXT\n");
        return false;
    }
}

bool callGlProgramUniform3iEXT(Stack* stack, bool pushReturn) {
    int32_t v2 = stack->pop<int32_t>();
    int32_t v1 = stack->pop<int32_t>();
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ")\n",
                   program, location, v0, v1, v2);
        if (glProgramUniform3iEXT != nullptr) {
            glProgramUniform3iEXT(program, location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3iEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3iEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3iEXT\n");
        return false;
    }
}

bool callGlProgramUniform3ivEXT(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform3ivEXT != nullptr) {
            glProgramUniform3ivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3ivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3ivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3ivEXT\n");
        return false;
    }
}

bool callGlProgramUniform3uiEXT(Stack* stack, bool pushReturn) {
    uint32_t v2 = stack->pop<uint32_t>();
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32
                   ", %" PRIu32 ")\n",
                   program, location, v0, v1, v2);
        if (glProgramUniform3uiEXT != nullptr) {
            glProgramUniform3uiEXT(program, location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3uiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3uiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3uiEXT\n");
        return false;
    }
}

bool callGlProgramUniform3uivEXT(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform3uivEXT != nullptr) {
            glProgramUniform3uivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3uivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3uivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3uivEXT\n");
        return false;
    }
}

bool callGlProgramUniform4fEXT(Stack* stack, bool pushReturn) {
    float v3 = stack->pop<float>();
    float v2 = stack->pop<float>();
    float v1 = stack->pop<float>();
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4fEXT(%" PRIu32 ", %" PRId32 ", %f, %f, %f, %f)\n", program,
                   location, v0, v1, v2, v3);
        if (glProgramUniform4fEXT != nullptr) {
            glProgramUniform4fEXT(program, location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4fEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4fEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4fEXT\n");
        return false;
    }
}

bool callGlProgramUniform4fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform4fvEXT != nullptr) {
            glProgramUniform4fvEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4fvEXT\n");
        return false;
    }
}

bool callGlProgramUniform4iEXT(Stack* stack, bool pushReturn) {
    int32_t v3 = stack->pop<int32_t>();
    int32_t v2 = stack->pop<int32_t>();
    int32_t v1 = stack->pop<int32_t>();
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4iEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ")\n",
                   program, location, v0, v1, v2, v3);
        if (glProgramUniform4iEXT != nullptr) {
            glProgramUniform4iEXT(program, location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4iEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4iEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4iEXT\n");
        return false;
    }
}

bool callGlProgramUniform4ivEXT(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4ivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform4ivEXT != nullptr) {
            glProgramUniform4ivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4ivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4ivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4ivEXT\n");
        return false;
    }
}

bool callGlProgramUniform4uiEXT(Stack* stack, bool pushReturn) {
    uint32_t v3 = stack->pop<uint32_t>();
    uint32_t v2 = stack->pop<uint32_t>();
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4uiEXT(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32
                   ", %" PRIu32 ", %" PRIu32 ")\n",
                   program, location, v0, v1, v2, v3);
        if (glProgramUniform4uiEXT != nullptr) {
            glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4uiEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4uiEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4uiEXT\n");
        return false;
    }
}

bool callGlProgramUniform4uivEXT(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4uivEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform4uivEXT != nullptr) {
            glProgramUniform4uivEXT(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4uivEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4uivEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4uivEXT\n");
        return false;
    }
}

bool callGlProgramUniformHandleui64NV(Stack* stack, bool pushReturn) {
    uint64_t value = stack->pop<uint64_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformHandleui64NV(%" PRIu32 ", %" PRId32 ", %" PRIu64 ")\n", program,
                   location, value);
        if (glProgramUniformHandleui64NV != nullptr) {
            glProgramUniformHandleui64NV(program, location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformHandleui64NV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformHandleui64NV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformHandleui64NV\n");
        return false;
    }
}

bool callGlProgramUniformHandleui64vNV(Stack* stack, bool pushReturn) {
    uint64_t* values = stack->pop<uint64_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformHandleui64vNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n",
                   program, location, count, values);
        if (glProgramUniformHandleui64vNV != nullptr) {
            glProgramUniformHandleui64vNV(program, location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformHandleui64vNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformHandleui64vNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformHandleui64vNV\n");
        return false;
    }
}

bool callGlProgramUniformMatrix2fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix2fvEXT != nullptr) {
            glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix2fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix2fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix2x3fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix2x3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix2x3fvEXT != nullptr) {
            glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix2x3fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramUniformMatrix2x3fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix2x3fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix2x4fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix2x4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix2x4fvEXT != nullptr) {
            glProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix2x4fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramUniformMatrix2x4fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix2x4fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix3fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix3fvEXT != nullptr) {
            glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix3fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix3fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix3x2fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix3x2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix3x2fvEXT != nullptr) {
            glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix3x2fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramUniformMatrix3x2fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix3x2fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix3x4fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix3x4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix3x4fvEXT != nullptr) {
            glProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix3x4fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramUniformMatrix3x4fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix3x4fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix4fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix4fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix4fvEXT != nullptr) {
            glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix4fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix4fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix4x2fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix4x2fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix4x2fvEXT != nullptr) {
            glProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix4x2fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramUniformMatrix4x2fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix4x2fvEXT\n");
        return false;
    }
}

bool callGlProgramUniformMatrix4x3fvEXT(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix4x3fvEXT(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix4x3fvEXT != nullptr) {
            glProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix4x3fvEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glProgramUniformMatrix4x3fvEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix4x3fvEXT\n");
        return false;
    }
}

bool callGlPushGroupMarkerEXT(Stack* stack, bool pushReturn) {
    char* marker = stack->pop<char*>();
    int32_t length = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glPushGroupMarkerEXT(%" PRId32 ", %p)\n", length, marker);
        if (glPushGroupMarkerEXT != nullptr) {
            glPushGroupMarkerEXT(length, marker);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPushGroupMarkerEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPushGroupMarkerEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPushGroupMarkerEXT\n");
        return false;
    }
}

bool callGlQueryCounterEXT(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    uint32_t query = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glQueryCounterEXT(%" PRIu32 ", %u)\n", query, target);
        if (glQueryCounterEXT != nullptr) {
            glQueryCounterEXT(query, target);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glQueryCounterEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glQueryCounterEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glQueryCounterEXT\n");
        return false;
    }
}

bool callGlReadBufferIndexedEXT(Stack* stack, bool pushReturn) {
    int32_t index = stack->pop<int32_t>();
    GLenum src = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glReadBufferIndexedEXT(%u, %" PRId32 ")\n", src, index);
        if (glReadBufferIndexedEXT != nullptr) {
            glReadBufferIndexedEXT(src, index);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glReadBufferIndexedEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glReadBufferIndexedEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glReadBufferIndexedEXT\n");
        return false;
    }
}

bool callGlReadBufferNV(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glReadBufferNV(%u)\n", mode);
        if (glReadBufferNV != nullptr) {
            glReadBufferNV(mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glReadBufferNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glReadBufferNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glReadBufferNV\n");
        return false;
    }
}

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

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

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

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

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

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

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

bool callGlResolveMultisampleFramebufferAPPLE(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glResolveMultisampleFramebufferAPPLE()\n");
        if (glResolveMultisampleFramebufferAPPLE != nullptr) {
            glResolveMultisampleFramebufferAPPLE();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glResolveMultisampleFramebufferAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function "
                    "glResolveMultisampleFramebufferAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glResolveMultisampleFramebufferAPPLE\n");
        return false;
    }
}

bool callGlSamplerParameterIivOES(Stack* stack, bool pushReturn) {
    int32_t* param = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSamplerParameterIivOES(%" PRIu32 ", %u, %p)\n", sampler, pname, param);
        if (glSamplerParameterIivOES != nullptr) {
            glSamplerParameterIivOES(sampler, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSamplerParameterIivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSamplerParameterIivOES\n");
        return false;
    }
}

bool callGlSamplerParameterIuivOES(Stack* stack, bool pushReturn) {
    uint32_t* param = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSamplerParameterIuivOES(%" PRIu32 ", %u, %p)\n", sampler, pname, param);
        if (glSamplerParameterIuivOES != nullptr) {
            glSamplerParameterIuivOES(sampler, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSamplerParameterIuivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSamplerParameterIuivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSamplerParameterIuivOES\n");
        return false;
    }
}

bool callGlScissorArrayvNV(Stack* stack, bool pushReturn) {
    int32_t* v = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    uint32_t first = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glScissorArrayvNV(%" PRIu32 ", %" PRId32 ", %p)\n", first, count, v);
        if (glScissorArrayvNV != nullptr) {
            glScissorArrayvNV(first, count, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glScissorArrayvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glScissorArrayvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glScissorArrayvNV\n");
        return false;
    }
}

bool callGlScissorIndexedNV(Stack* stack, bool pushReturn) {
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t bottom = stack->pop<int32_t>();
    int32_t left = stack->pop<int32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glScissorIndexedNV(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ")\n",
                   index, left, bottom, width, height);
        if (glScissorIndexedNV != nullptr) {
            glScissorIndexedNV(index, left, bottom, width, height);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glScissorIndexedNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glScissorIndexedNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glScissorIndexedNV\n");
        return false;
    }
}

bool callGlScissorIndexedvNV(Stack* stack, bool pushReturn) {
    int32_t* v = stack->pop<int32_t*>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glScissorIndexedvNV(%" PRIu32 ", %p)\n", index, v);
        if (glScissorIndexedvNV != nullptr) {
            glScissorIndexedvNV(index, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glScissorIndexedvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glScissorIndexedvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glScissorIndexedvNV\n");
        return false;
    }
}

bool callGlSelectPerfMonitorCountersAMD(Stack* stack, bool pushReturn) {
    uint32_t* counterList = stack->pop<uint32_t*>();
    int32_t numCounters = stack->pop<int32_t>();
    uint32_t group = stack->pop<uint32_t>();
    uint8_t enable = stack->pop<uint8_t>();
    uint32_t monitor = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSelectPerfMonitorCountersAMD(%" PRIu32 ", %" PRIu8 ", %" PRIu32 ", %" PRId32
                   ", %p)\n",
                   monitor, enable, group, numCounters, counterList);
        if (glSelectPerfMonitorCountersAMD != nullptr) {
            glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSelectPerfMonitorCountersAMD returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glSelectPerfMonitorCountersAMD\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSelectPerfMonitorCountersAMD\n");
        return false;
    }
}

bool callGlSetFenceNV(Stack* stack, bool pushReturn) {
    GLenum condition = stack->pop<GLenum>();
    uint32_t fence = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSetFenceNV(%" PRIu32 ", %u)\n", fence, condition);
        if (glSetFenceNV != nullptr) {
            glSetFenceNV(fence, condition);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSetFenceNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSetFenceNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSetFenceNV\n");
        return false;
    }
}

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

bool callGlStencilFillPathInstancedNV(Stack* stack, bool pushReturn) {
    float* transformValues = stack->pop<float*>();
    GLenum transformType = stack->pop<GLenum>();
    uint32_t mask = stack->pop<uint32_t>();
    GLenum fillMode = stack->pop<GLenum>();
    uint32_t pathBase = stack->pop<uint32_t>();
    void* paths = stack->pop<void*>();
    GLenum pathNameType = stack->pop<GLenum>();
    int32_t numPaths = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilFillPathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %u, %" PRIu32
                   ", %u, %p)\n",
                   numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType,
                   transformValues);
        if (glStencilFillPathInstancedNV != nullptr) {
            glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask,
                                         transformType, transformValues);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilFillPathInstancedNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilFillPathInstancedNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilFillPathInstancedNV\n");
        return false;
    }
}

bool callGlStencilFillPathNV(Stack* stack, bool pushReturn) {
    uint32_t mask = stack->pop<uint32_t>();
    GLenum fillMode = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilFillPathNV(%" PRIu32 ", %u, %" PRIu32 ")\n", path, fillMode, mask);
        if (glStencilFillPathNV != nullptr) {
            glStencilFillPathNV(path, fillMode, mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilFillPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilFillPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilFillPathNV\n");
        return false;
    }
}

bool callGlStencilStrokePathInstancedNV(Stack* stack, bool pushReturn) {
    float* transformValues = stack->pop<float*>();
    GLenum transformType = stack->pop<GLenum>();
    uint32_t mask = stack->pop<uint32_t>();
    int32_t reference = stack->pop<int32_t>();
    uint32_t pathBase = stack->pop<uint32_t>();
    void* paths = stack->pop<void*>();
    GLenum pathNameType = stack->pop<GLenum>();
    int32_t numPaths = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilStrokePathInstancedNV(%" PRId32 ", %u, %p, %" PRIu32 ", %" PRId32
                   ", %" PRIu32 ", %u, %p)\n",
                   numPaths, pathNameType, paths, pathBase, reference, mask, transformType,
                   transformValues);
        if (glStencilStrokePathInstancedNV != nullptr) {
            glStencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask,
                                           transformType, transformValues);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilStrokePathInstancedNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glStencilStrokePathInstancedNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilStrokePathInstancedNV\n");
        return false;
    }
}

bool callGlStencilStrokePathNV(Stack* stack, bool pushReturn) {
    uint32_t mask = stack->pop<uint32_t>();
    int32_t reference = stack->pop<int32_t>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilStrokePathNV(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")\n", path,
                   reference, mask);
        if (glStencilStrokePathNV != nullptr) {
            glStencilStrokePathNV(path, reference, mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilStrokePathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilStrokePathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilStrokePathNV\n");
        return false;
    }
}

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

bool callGlStencilThenCoverFillPathNV(Stack* stack, bool pushReturn) {
    GLenum coverMode = stack->pop<GLenum>();
    uint32_t mask = stack->pop<uint32_t>();
    GLenum fillMode = stack->pop<GLenum>();
    uint32_t path = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilThenCoverFillPathNV(%" PRIu32 ", %u, %" PRIu32 ", %u)\n", path,
                   fillMode, mask, coverMode);
        if (glStencilThenCoverFillPathNV != nullptr) {
            glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilThenCoverFillPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilThenCoverFillPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilThenCoverFillPathNV\n");
        return false;
    }
}

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

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

bool callGlTestFenceNV(Stack* stack, bool pushReturn) {
    uint32_t fence = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glTestFenceNV(%" PRIu32 ")\n", fence);
        if (glTestFenceNV != nullptr) {
            uint8_t return_value = glTestFenceNV(fence);
            GAPID_INFO("Returned: %" PRIu8 "\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTestFenceNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTestFenceNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTestFenceNV\n");
        return false;
    }
}

bool callGlTexBufferOES(Stack* stack, bool pushReturn) {
    uint32_t buffer = stack->pop<uint32_t>();
    GLenum internalformat = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexBufferOES(%u, %u, %" PRIu32 ")\n", target, internalformat, buffer);
        if (glTexBufferOES != nullptr) {
            glTexBufferOES(target, internalformat, buffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexBufferOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexBufferOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexBufferOES\n");
        return false;
    }
}

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

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

bool callGlTexPageCommitmentARB(Stack* stack, bool pushReturn) {
    uint8_t commit = stack->pop<uint8_t>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t zoffset = stack->pop<int32_t>();
    int32_t yoffset = stack->pop<int32_t>();
    int32_t xoffset = stack->pop<int32_t>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexPageCommitmentARB(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRIu8 ")\n",
                   target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
        if (glTexPageCommitmentARB != nullptr) {
            glTexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth,
                                   commit);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexPageCommitmentARB returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexPageCommitmentARB\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexPageCommitmentARB\n");
        return false;
    }
}

bool callGlTexParameterIivOES(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameterIivOES(%u, %u, %p)\n", target, pname, params);
        if (glTexParameterIivOES != nullptr) {
            glTexParameterIivOES(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameterIivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameterIivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameterIivOES\n");
        return false;
    }
}

bool callGlTexParameterIuivOES(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameterIuivOES(%u, %u, %p)\n", target, pname, params);
        if (glTexParameterIuivOES != nullptr) {
            glTexParameterIuivOES(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameterIuivOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameterIuivOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameterIuivOES\n");
        return false;
    }
}

bool callGlTexStorage1DEXT(Stack* stack, bool pushReturn) {
    int32_t width = stack->pop<int32_t>();
    GLenum format = stack->pop<GLenum>();
    int32_t levels = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexStorage1DEXT(%u, %" PRId32 ", %u, %" PRId32 ")\n", target, levels, format,
                   width);
        if (glTexStorage1DEXT != nullptr) {
            glTexStorage1DEXT(target, levels, format, width);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexStorage1DEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexStorage1DEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexStorage1DEXT\n");
        return false;
    }
}

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

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

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

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

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

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

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

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

bool callGlTransformPathNV(Stack* stack, bool pushReturn) {
    float* transformValues = stack->pop<float*>();
    GLenum transformType = stack->pop<GLenum>();
    uint32_t srcPath = stack->pop<uint32_t>();
    uint32_t resultPath = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glTransformPathNV(%" PRIu32 ", %" PRIu32 ", %u, %p)\n", resultPath, srcPath,
                   transformType, transformValues);
        if (glTransformPathNV != nullptr) {
            glTransformPathNV(resultPath, srcPath, transformType, transformValues);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTransformPathNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTransformPathNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTransformPathNV\n");
        return false;
    }
}

bool callGlUniformHandleui64NV(Stack* stack, bool pushReturn) {
    uint64_t value = stack->pop<uint64_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformHandleui64NV(%" PRId32 ", %" PRIu64 ")\n", location, value);
        if (glUniformHandleui64NV != nullptr) {
            glUniformHandleui64NV(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformHandleui64NV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformHandleui64NV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformHandleui64NV\n");
        return false;
    }
}

bool callGlUniformHandleui64vNV(Stack* stack, bool pushReturn) {
    uint64_t* value = stack->pop<uint64_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformHandleui64vNV(%" PRId32 ", %" PRId32 ", %p)\n", location, count,
                   value);
        if (glUniformHandleui64vNV != nullptr) {
            glUniformHandleui64vNV(location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformHandleui64vNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformHandleui64vNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformHandleui64vNV\n");
        return false;
    }
}

bool callGlUniformMatrix2x3fvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix2x3fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix2x3fvNV != nullptr) {
            glUniformMatrix2x3fvNV(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix2x3fvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x3fvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix2x3fvNV\n");
        return false;
    }
}

bool callGlUniformMatrix2x4fvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix2x4fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix2x4fvNV != nullptr) {
            glUniformMatrix2x4fvNV(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix2x4fvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x4fvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix2x4fvNV\n");
        return false;
    }
}

bool callGlUniformMatrix3x2fvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix3x2fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix3x2fvNV != nullptr) {
            glUniformMatrix3x2fvNV(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix3x2fvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x2fvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix3x2fvNV\n");
        return false;
    }
}

bool callGlUniformMatrix3x4fvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix3x4fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix3x4fvNV != nullptr) {
            glUniformMatrix3x4fvNV(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix3x4fvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x4fvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix3x4fvNV\n");
        return false;
    }
}

bool callGlUniformMatrix4x2fvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix4x2fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix4x2fvNV != nullptr) {
            glUniformMatrix4x2fvNV(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix4x2fvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x2fvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix4x2fvNV\n");
        return false;
    }
}

bool callGlUniformMatrix4x3fvNV(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix4x3fvNV(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix4x3fvNV != nullptr) {
            glUniformMatrix4x3fvNV(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix4x3fvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x3fvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix4x3fvNV\n");
        return false;
    }
}

bool callGlUnmapBufferOES(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glUnmapBufferOES(%u)\n", target);
        if (glUnmapBufferOES != nullptr) {
            uint8_t return_value = glUnmapBufferOES(target);
            GAPID_INFO("Returned: %" PRIu8 "\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUnmapBufferOES returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUnmapBufferOES\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUnmapBufferOES\n");
        return false;
    }
}

bool callGlUseProgramStagesEXT(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    GLbitfield stages = stack->pop<GLbitfield>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUseProgramStagesEXT(%" PRIu32 ", %u, %" PRIu32 ")\n", pipeline, stages,
                   program);
        if (glUseProgramStagesEXT != nullptr) {
            glUseProgramStagesEXT(pipeline, stages, program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUseProgramStagesEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUseProgramStagesEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUseProgramStagesEXT\n");
        return false;
    }
}

bool callGlValidateProgramPipelineEXT(Stack* stack, bool pushReturn) {
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glValidateProgramPipelineEXT(%" PRIu32 ")\n", pipeline);
        if (glValidateProgramPipelineEXT != nullptr) {
            glValidateProgramPipelineEXT(pipeline);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glValidateProgramPipelineEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glValidateProgramPipelineEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glValidateProgramPipelineEXT\n");
        return false;
    }
}

bool callGlVertexAttribDivisorANGLE(Stack* stack, bool pushReturn) {
    uint32_t divisor = stack->pop<uint32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribDivisorANGLE(%" PRIu32 ", %" PRIu32 ")\n", index, divisor);
        if (glVertexAttribDivisorANGLE != nullptr) {
            glVertexAttribDivisorANGLE(index, divisor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribDivisorANGLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisorANGLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribDivisorANGLE\n");
        return false;
    }
}

bool callGlVertexAttribDivisorEXT(Stack* stack, bool pushReturn) {
    uint32_t divisor = stack->pop<uint32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribDivisorEXT(%" PRIu32 ", %" PRIu32 ")\n", index, divisor);
        if (glVertexAttribDivisorEXT != nullptr) {
            glVertexAttribDivisorEXT(index, divisor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribDivisorEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisorEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribDivisorEXT\n");
        return false;
    }
}

bool callGlVertexAttribDivisorNV(Stack* stack, bool pushReturn) {
    uint32_t divisor = stack->pop<uint32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribDivisorNV(%" PRIu32 ", %" PRIu32 ")\n", index, divisor);
        if (glVertexAttribDivisorNV != nullptr) {
            glVertexAttribDivisorNV(index, divisor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribDivisorNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisorNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribDivisorNV\n");
        return false;
    }
}

bool callGlViewportArrayvNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    uint32_t first = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glViewportArrayvNV(%" PRIu32 ", %" PRId32 ", %p)\n", first, count, v);
        if (glViewportArrayvNV != nullptr) {
            glViewportArrayvNV(first, count, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glViewportArrayvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glViewportArrayvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glViewportArrayvNV\n");
        return false;
    }
}

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

bool callGlViewportIndexedfvNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glViewportIndexedfvNV(%" PRIu32 ", %p)\n", index, v);
        if (glViewportIndexedfvNV != nullptr) {
            glViewportIndexedfvNV(index, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glViewportIndexedfvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glViewportIndexedfvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glViewportIndexedfvNV\n");
        return false;
    }
}

bool callGlWaitSyncAPPLE(Stack* stack, bool pushReturn) {
    uint64_t timeout = stack->pop<uint64_t>();
    GLbitfield flag = stack->pop<GLbitfield>();
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glWaitSyncAPPLE(%" PRIu64 ", %u, %" PRIu64 ")\n", sync, flag, timeout);
        if (glWaitSyncAPPLE != nullptr) {
            glWaitSyncAPPLE(sync, flag, timeout);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glWaitSyncAPPLE returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glWaitSyncAPPLE\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glWaitSyncAPPLE\n");
        return false;
    }
}

bool callGlWeightPathsNV(Stack* stack, bool pushReturn) {
    float* weights = stack->pop<float*>();
    uint32_t* paths = stack->pop<uint32_t*>();
    int32_t numPaths = stack->pop<int32_t>();
    uint32_t resultPath = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glWeightPathsNV(%" PRIu32 ", %" PRId32 ", %p, %p)\n", resultPath, numPaths,
                   paths, weights);
        if (glWeightPathsNV != nullptr) {
            glWeightPathsNV(resultPath, numPaths, paths, weights);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glWeightPathsNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glWeightPathsNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glWeightPathsNV\n");
        return false;
    }
}

bool callGlCoverageModulationNV(Stack* stack, bool pushReturn) {
    GLenum components = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverageModulationNV(%u)\n", components);
        if (glCoverageModulationNV != nullptr) {
            glCoverageModulationNV(components);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverageModulationNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverageModulationNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverageModulationNV\n");
        return false;
    }
}

bool callGlCoverageModulationTableNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCoverageModulationTableNV(%" PRId32 ", %p)\n", n, v);
        if (glCoverageModulationTableNV != nullptr) {
            glCoverageModulationTableNV(n, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCoverageModulationTableNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCoverageModulationTableNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCoverageModulationTableNV\n");
        return false;
    }
}

bool callGlFragmentCoverageColorNV(Stack* stack, bool pushReturn) {
    uint32_t color = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glFragmentCoverageColorNV(%" PRIu32 ")\n", color);
        if (glFragmentCoverageColorNV != nullptr) {
            glFragmentCoverageColorNV(color);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFragmentCoverageColorNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFragmentCoverageColorNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFragmentCoverageColorNV\n");
        return false;
    }
}

bool callGlFramebufferSampleLocationsfvNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    uint32_t start = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFramebufferSampleLocationsfvNV(%u, %" PRIu32 ", %" PRId32 ", %p)\n", target,
                   start, count, v);
        if (glFramebufferSampleLocationsfvNV != nullptr) {
            glFramebufferSampleLocationsfvNV(target, start, count, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFramebufferSampleLocationsfvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glFramebufferSampleLocationsfvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFramebufferSampleLocationsfvNV\n");
        return false;
    }
}

bool callGlGetCoverageModulationTableNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    int32_t bufsize = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetCoverageModulationTableNV(%" PRId32 ", %p)\n", bufsize, v);
        if (glGetCoverageModulationTableNV != nullptr) {
            glGetCoverageModulationTableNV(bufsize, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetCoverageModulationTableNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glGetCoverageModulationTableNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetCoverageModulationTableNV\n");
        return false;
    }
}

bool callGlNamedFramebufferSampleLocationsfvNV(Stack* stack, bool pushReturn) {
    float* v = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    uint32_t start = stack->pop<uint32_t>();
    uint32_t framebuffer = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glNamedFramebufferSampleLocationsfvNV(%" PRIu32 ", %" PRIu32 ", %" PRId32
                   ", %p)\n",
                   framebuffer, start, count, v);
        if (glNamedFramebufferSampleLocationsfvNV != nullptr) {
            glNamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glNamedFramebufferSampleLocationsfvNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function "
                    "glNamedFramebufferSampleLocationsfvNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glNamedFramebufferSampleLocationsfvNV\n");
        return false;
    }
}

bool callGlRasterSamplesEXT(Stack* stack, bool pushReturn) {
    uint8_t fixedsamplelocations = stack->pop<uint8_t>();
    uint32_t samples = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glRasterSamplesEXT(%" PRIu32 ", %" PRIu8 ")\n", samples, fixedsamplelocations);
        if (glRasterSamplesEXT != nullptr) {
            glRasterSamplesEXT(samples, fixedsamplelocations);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glRasterSamplesEXT returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glRasterSamplesEXT\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glRasterSamplesEXT\n");
        return false;
    }
}

bool callGlResolveDepthValuesNV(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glResolveDepthValuesNV()\n");
        if (glResolveDepthValuesNV != nullptr) {
            glResolveDepthValuesNV();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glResolveDepthValuesNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glResolveDepthValuesNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glResolveDepthValuesNV\n");
        return false;
    }
}

bool callGlSubpixelPrecisionBiasNV(Stack* stack, bool pushReturn) {
    uint32_t ybits = stack->pop<uint32_t>();
    uint32_t xbits = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSubpixelPrecisionBiasNV(%" PRIu32 ", %" PRIu32 ")\n", xbits, ybits);
        if (glSubpixelPrecisionBiasNV != nullptr) {
            glSubpixelPrecisionBiasNV(xbits, ybits);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSubpixelPrecisionBiasNV returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSubpixelPrecisionBiasNV\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSubpixelPrecisionBiasNV\n");
        return false;
    }
}

bool callGlBlendColor(Stack* stack, bool pushReturn) {
    float alpha = stack->pop<float>();
    float blue = stack->pop<float>();
    float green = stack->pop<float>();
    float red = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendColor(%f, %f, %f, %f)\n", red, green, blue, alpha);
        if (glBlendColor != nullptr) {
            glBlendColor(red, green, blue, alpha);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendColor returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendColor\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendColor\n");
        return false;
    }
}

bool callGlBlendEquation(Stack* stack, bool pushReturn) {
    GLenum equation = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendEquation(%u)\n", equation);
        if (glBlendEquation != nullptr) {
            glBlendEquation(equation);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendEquation returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendEquation\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendEquation\n");
        return false;
    }
}

bool callGlBlendEquationSeparate(Stack* stack, bool pushReturn) {
    GLenum alpha = stack->pop<GLenum>();
    GLenum rgb = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendEquationSeparate(%u, %u)\n", rgb, alpha);
        if (glBlendEquationSeparate != nullptr) {
            glBlendEquationSeparate(rgb, alpha);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendEquationSeparate returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendEquationSeparate\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendEquationSeparate\n");
        return false;
    }
}

bool callGlBlendFunc(Stack* stack, bool pushReturn) {
    GLenum dst_factor = stack->pop<GLenum>();
    GLenum src_factor = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendFunc(%u, %u)\n", src_factor, dst_factor);
        if (glBlendFunc != nullptr) {
            glBlendFunc(src_factor, dst_factor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendFunc returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendFunc\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendFunc\n");
        return false;
    }
}

bool callGlBlendFuncSeparate(Stack* stack, bool pushReturn) {
    GLenum dst_factor_alpha = stack->pop<GLenum>();
    GLenum src_factor_alpha = stack->pop<GLenum>();
    GLenum dst_factor_rgb = stack->pop<GLenum>();
    GLenum src_factor_rgb = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBlendFuncSeparate(%u, %u, %u, %u)\n", src_factor_rgb, dst_factor_rgb,
                   src_factor_alpha, dst_factor_alpha);
        if (glBlendFuncSeparate != nullptr) {
            glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, src_factor_alpha, dst_factor_alpha);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBlendFuncSeparate returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBlendFuncSeparate\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBlendFuncSeparate\n");
        return false;
    }
}

bool callGlDepthFunc(Stack* stack, bool pushReturn) {
    GLenum function = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDepthFunc(%u)\n", function);
        if (glDepthFunc != nullptr) {
            glDepthFunc(function);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDepthFunc returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthFunc\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthFunc\n");
        return false;
    }
}

bool callGlSampleCoverage(Stack* stack, bool pushReturn) {
    bool invert = stack->pop<bool>();
    float value = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glSampleCoverage(%f, %d)\n", value, invert);
        if (glSampleCoverage != nullptr) {
            glSampleCoverage(value, invert);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSampleCoverage returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSampleCoverage\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSampleCoverage\n");
        return false;
    }
}

bool callGlSampleMaski(Stack* stack, bool pushReturn) {
    GLbitfield mask = stack->pop<GLbitfield>();
    uint32_t maskNumber = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSampleMaski(%" PRIu32 ", %u)\n", maskNumber, mask);
        if (glSampleMaski != nullptr) {
            glSampleMaski(maskNumber, mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSampleMaski returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSampleMaski\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSampleMaski\n");
        return false;
    }
}

bool callGlScissor(Stack* stack, bool pushReturn) {
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t y = stack->pop<int32_t>();
    int32_t x = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glScissor(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", x, y, width,
                   height);
        if (glScissor != nullptr) {
            glScissor(x, y, width, height);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glScissor returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glScissor\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glScissor\n");
        return false;
    }
}

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

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

bool callGlStencilOp(Stack* stack, bool pushReturn) {
    GLenum zpass = stack->pop<GLenum>();
    GLenum zfail = stack->pop<GLenum>();
    GLenum fail = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilOp(%u, %u, %u)\n", fail, zfail, zpass);
        if (glStencilOp != nullptr) {
            glStencilOp(fail, zfail, zpass);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilOp returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilOp\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilOp\n");
        return false;
    }
}

bool callGlStencilOpSeparate(Stack* stack, bool pushReturn) {
    GLenum stencil_pass_depth_pass = stack->pop<GLenum>();
    GLenum stencil_pass_depth_fail = stack->pop<GLenum>();
    GLenum stencil_fail = stack->pop<GLenum>();
    GLenum face = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilOpSeparate(%u, %u, %u, %u)\n", face, stencil_fail,
                   stencil_pass_depth_fail, stencil_pass_depth_pass);
        if (glStencilOpSeparate != nullptr) {
            glStencilOpSeparate(face, stencil_fail, stencil_pass_depth_fail,
                                stencil_pass_depth_pass);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilOpSeparate returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilOpSeparate\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilOpSeparate\n");
        return false;
    }
}

bool callGlBindFramebuffer(Stack* stack, bool pushReturn) {
    uint32_t framebuffer = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBindFramebuffer(%u, %" PRIu32 ")\n", target, framebuffer);
        if (glBindFramebuffer != nullptr) {
            glBindFramebuffer(target, framebuffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindFramebuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindFramebuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindFramebuffer\n");
        return false;
    }
}

bool callGlBindRenderbuffer(Stack* stack, bool pushReturn) {
    uint32_t renderbuffer = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBindRenderbuffer(%u, %" PRIu32 ")\n", target, renderbuffer);
        if (glBindRenderbuffer != nullptr) {
            glBindRenderbuffer(target, renderbuffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindRenderbuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindRenderbuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindRenderbuffer\n");
        return false;
    }
}

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

bool callGlCheckFramebufferStatus(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCheckFramebufferStatus(%u)\n", target);
        if (glCheckFramebufferStatus != nullptr) {
            GLenum return_value = glCheckFramebufferStatus(target);
            GAPID_INFO("Returned: %u\n", return_value);
            if (pushReturn) {
                stack->push<GLenum>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCheckFramebufferStatus returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCheckFramebufferStatus\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCheckFramebufferStatus\n");
        return false;
    }
}

bool callGlClear(Stack* stack, bool pushReturn) {
    GLbitfield mask = stack->pop<GLbitfield>();
    if (stack->isValid()) {
        GAPID_INFO("glClear(%u)\n", mask);
        if (glClear != nullptr) {
            glClear(mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClear returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClear\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClear\n");
        return false;
    }
}

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

bool callGlClearBufferfv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t drawbuffer = stack->pop<int32_t>();
    GLenum buffer = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glClearBufferfv(%u, %" PRId32 ", %p)\n", buffer, drawbuffer, value);
        if (glClearBufferfv != nullptr) {
            glClearBufferfv(buffer, drawbuffer, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClearBufferfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearBufferfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearBufferfv\n");
        return false;
    }
}

bool callGlClearBufferiv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t drawbuffer = stack->pop<int32_t>();
    GLenum buffer = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glClearBufferiv(%u, %" PRId32 ", %p)\n", buffer, drawbuffer, value);
        if (glClearBufferiv != nullptr) {
            glClearBufferiv(buffer, drawbuffer, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClearBufferiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearBufferiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearBufferiv\n");
        return false;
    }
}

bool callGlClearBufferuiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t drawbuffer = stack->pop<int32_t>();
    GLenum buffer = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glClearBufferuiv(%u, %" PRId32 ", %p)\n", buffer, drawbuffer, value);
        if (glClearBufferuiv != nullptr) {
            glClearBufferuiv(buffer, drawbuffer, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClearBufferuiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearBufferuiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearBufferuiv\n");
        return false;
    }
}

bool callGlClearColor(Stack* stack, bool pushReturn) {
    float a = stack->pop<float>();
    float b = stack->pop<float>();
    float g = stack->pop<float>();
    float r = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glClearColor(%f, %f, %f, %f)\n", r, g, b, a);
        if (glClearColor != nullptr) {
            glClearColor(r, g, b, a);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClearColor returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearColor\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearColor\n");
        return false;
    }
}

bool callGlClearDepthf(Stack* stack, bool pushReturn) {
    float depth = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glClearDepthf(%f)\n", depth);
        if (glClearDepthf != nullptr) {
            glClearDepthf(depth);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClearDepthf returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearDepthf\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearDepthf\n");
        return false;
    }
}

bool callGlClearStencil(Stack* stack, bool pushReturn) {
    int32_t stencil = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glClearStencil(%" PRId32 ")\n", stencil);
        if (glClearStencil != nullptr) {
            glClearStencil(stencil);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClearStencil returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClearStencil\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClearStencil\n");
        return false;
    }
}

bool callGlColorMask(Stack* stack, bool pushReturn) {
    bool alpha = stack->pop<bool>();
    bool blue = stack->pop<bool>();
    bool green = stack->pop<bool>();
    bool red = stack->pop<bool>();
    if (stack->isValid()) {
        GAPID_INFO("glColorMask(%d, %d, %d, %d)\n", red, green, blue, alpha);
        if (glColorMask != nullptr) {
            glColorMask(red, green, blue, alpha);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glColorMask returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glColorMask\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glColorMask\n");
        return false;
    }
}

bool callGlDeleteFramebuffers(Stack* stack, bool pushReturn) {
    uint32_t* framebuffers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteFramebuffers(%" PRId32 ", %p)\n", count, framebuffers);
        if (glDeleteFramebuffers != nullptr) {
            glDeleteFramebuffers(count, framebuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteFramebuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteFramebuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteFramebuffers\n");
        return false;
    }
}

bool callGlDeleteRenderbuffers(Stack* stack, bool pushReturn) {
    uint32_t* renderbuffers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteRenderbuffers(%" PRId32 ", %p)\n", count, renderbuffers);
        if (glDeleteRenderbuffers != nullptr) {
            glDeleteRenderbuffers(count, renderbuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteRenderbuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteRenderbuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteRenderbuffers\n");
        return false;
    }
}

bool callGlDepthMask(Stack* stack, bool pushReturn) {
    bool enabled = stack->pop<bool>();
    if (stack->isValid()) {
        GAPID_INFO("glDepthMask(%d)\n", enabled);
        if (glDepthMask != nullptr) {
            glDepthMask(enabled);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDepthMask returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthMask\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthMask\n");
        return false;
    }
}

bool callGlFramebufferParameteri(Stack* stack, bool pushReturn) {
    int32_t param = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFramebufferParameteri(%u, %u, %" PRId32 ")\n", target, pname, param);
        if (glFramebufferParameteri != nullptr) {
            glFramebufferParameteri(target, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFramebufferParameteri returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFramebufferParameteri\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFramebufferParameteri\n");
        return false;
    }
}

bool callGlFramebufferRenderbuffer(Stack* stack, bool pushReturn) {
    uint32_t renderbuffer = stack->pop<uint32_t>();
    GLenum renderbuffer_target = stack->pop<GLenum>();
    GLenum framebuffer_attachment = stack->pop<GLenum>();
    GLenum framebuffer_target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFramebufferRenderbuffer(%u, %u, %u, %" PRIu32 ")\n", framebuffer_target,
                   framebuffer_attachment, renderbuffer_target, renderbuffer);
        if (glFramebufferRenderbuffer != nullptr) {
            glFramebufferRenderbuffer(framebuffer_target, framebuffer_attachment,
                                      renderbuffer_target, renderbuffer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFramebufferRenderbuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFramebufferRenderbuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFramebufferRenderbuffer\n");
        return false;
    }
}

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

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

bool callGlGenFramebuffers(Stack* stack, bool pushReturn) {
    uint32_t* framebuffers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenFramebuffers(%" PRId32 ", %p)\n", count, framebuffers);
        if (glGenFramebuffers != nullptr) {
            glGenFramebuffers(count, framebuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenFramebuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenFramebuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenFramebuffers\n");
        return false;
    }
}

bool callGlGenRenderbuffers(Stack* stack, bool pushReturn) {
    uint32_t* renderbuffers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenRenderbuffers(%" PRId32 ", %p)\n", count, renderbuffers);
        if (glGenRenderbuffers != nullptr) {
            glGenRenderbuffers(count, renderbuffers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenRenderbuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenRenderbuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenRenderbuffers\n");
        return false;
    }
}

bool callGlGetFramebufferAttachmentParameteriv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum attachment = stack->pop<GLenum>();
    GLenum framebuffer_target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFramebufferAttachmentParameteriv(%u, %u, %u, %p)\n", framebuffer_target,
                   attachment, parameter, value);
        if (glGetFramebufferAttachmentParameteriv != nullptr) {
            glGetFramebufferAttachmentParameteriv(framebuffer_target, attachment, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFramebufferAttachmentParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function "
                    "glGetFramebufferAttachmentParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFramebufferAttachmentParameteriv\n");
        return false;
    }
}

bool callGlGetFramebufferParameteriv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFramebufferParameteriv(%u, %u, %p)\n", target, pname, params);
        if (glGetFramebufferParameteriv != nullptr) {
            glGetFramebufferParameteriv(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFramebufferParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFramebufferParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFramebufferParameteriv\n");
        return false;
    }
}

bool callGlGetRenderbufferParameteriv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetRenderbufferParameteriv(%u, %u, %p)\n", target, parameter, values);
        if (glGetRenderbufferParameteriv != nullptr) {
            glGetRenderbufferParameteriv(target, parameter, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetRenderbufferParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetRenderbufferParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetRenderbufferParameteriv\n");
        return false;
    }
}

bool callGlInvalidateFramebuffer(Stack* stack, bool pushReturn) {
    GLenum* attachments = stack->pop<GLenum*>();
    int32_t count = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glInvalidateFramebuffer(%u, %" PRId32 ", %p)\n", target, count, attachments);
        if (glInvalidateFramebuffer != nullptr) {
            glInvalidateFramebuffer(target, count, attachments);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glInvalidateFramebuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glInvalidateFramebuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glInvalidateFramebuffer\n");
        return false;
    }
}

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

bool callGlIsFramebuffer(Stack* stack, bool pushReturn) {
    uint32_t framebuffer = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsFramebuffer(%" PRIu32 ")\n", framebuffer);
        if (glIsFramebuffer != nullptr) {
            bool return_value = glIsFramebuffer(framebuffer);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsFramebuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsFramebuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsFramebuffer\n");
        return false;
    }
}

bool callGlIsRenderbuffer(Stack* stack, bool pushReturn) {
    uint32_t renderbuffer = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsRenderbuffer(%" PRIu32 ")\n", renderbuffer);
        if (glIsRenderbuffer != nullptr) {
            bool return_value = glIsRenderbuffer(renderbuffer);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsRenderbuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsRenderbuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsRenderbuffer\n");
        return false;
    }
}

bool callGlReadBuffer(Stack* stack, bool pushReturn) {
    GLenum src = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glReadBuffer(%u)\n", src);
        if (glReadBuffer != nullptr) {
            glReadBuffer(src);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glReadBuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glReadBuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glReadBuffer\n");
        return false;
    }
}

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

bool callGlRenderbufferStorage(Stack* stack, bool pushReturn) {
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    GLenum format = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glRenderbufferStorage(%u, %u, %" PRId32 ", %" PRId32 ")\n", target, format,
                   width, height);
        if (glRenderbufferStorage != nullptr) {
            glRenderbufferStorage(target, format, width, height);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glRenderbufferStorage returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glRenderbufferStorage\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glRenderbufferStorage\n");
        return false;
    }
}

bool callGlRenderbufferStorageMultisample(Stack* stack, bool pushReturn) {
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    GLenum format = stack->pop<GLenum>();
    int32_t samples = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glRenderbufferStorageMultisample(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32
                   ")\n",
                   target, samples, format, width, height);
        if (glRenderbufferStorageMultisample != nullptr) {
            glRenderbufferStorageMultisample(target, samples, format, width, height);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glRenderbufferStorageMultisample returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING(
                    "Attempted to call unsupported function glRenderbufferStorageMultisample\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glRenderbufferStorageMultisample\n");
        return false;
    }
}

bool callGlStencilMask(Stack* stack, bool pushReturn) {
    uint32_t mask = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilMask(%" PRIu32 ")\n", mask);
        if (glStencilMask != nullptr) {
            glStencilMask(mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilMask returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilMask\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilMask\n");
        return false;
    }
}

bool callGlStencilMaskSeparate(Stack* stack, bool pushReturn) {
    uint32_t mask = stack->pop<uint32_t>();
    GLenum face = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glStencilMaskSeparate(%u, %" PRIu32 ")\n", face, mask);
        if (glStencilMaskSeparate != nullptr) {
            glStencilMaskSeparate(face, mask);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glStencilMaskSeparate returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glStencilMaskSeparate\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glStencilMaskSeparate\n");
        return false;
    }
}

bool callGlDisable(Stack* stack, bool pushReturn) {
    GLenum capability = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glDisable(%u)\n", capability);
        if (glDisable != nullptr) {
            glDisable(capability);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDisable returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDisable\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDisable\n");
        return false;
    }
}

bool callGlEnable(Stack* stack, bool pushReturn) {
    GLenum capability = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glEnable(%u)\n", capability);
        if (glEnable != nullptr) {
            glEnable(capability);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEnable returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEnable\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEnable\n");
        return false;
    }
}

bool callGlFinish(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glFinish()\n");
        if (glFinish != nullptr) {
            glFinish();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFinish returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFinish\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFinish\n");
        return false;
    }
}

bool callGlFlush(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glFlush()\n");
        if (glFlush != nullptr) {
            glFlush();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFlush returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFlush\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFlush\n");
        return false;
    }
}

bool callGlFlushMappedBufferRange(Stack* stack, bool pushReturn) {
    int32_t length = stack->pop<int32_t>();
    int32_t offset = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFlushMappedBufferRange(%u, %" PRId32 ", %" PRId32 ")\n", target, offset,
                   length);
        if (glFlushMappedBufferRange != nullptr) {
            glFlushMappedBufferRange(target, offset, length);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFlushMappedBufferRange returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFlushMappedBufferRange\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFlushMappedBufferRange\n");
        return false;
    }
}

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

bool callGlHint(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glHint(%u, %u)\n", target, mode);
        if (glHint != nullptr) {
            glHint(target, mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glHint returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glHint\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glHint\n");
        return false;
    }
}

bool callGlActiveShaderProgram(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glActiveShaderProgram(%" PRIu32 ", %" PRIu32 ")\n", pipeline, program);
        if (glActiveShaderProgram != nullptr) {
            glActiveShaderProgram(pipeline, program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glActiveShaderProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glActiveShaderProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glActiveShaderProgram\n");
        return false;
    }
}

bool callGlAttachShader(Stack* stack, bool pushReturn) {
    uint32_t shader = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glAttachShader(%" PRIu32 ", %" PRIu32 ")\n", program, shader);
        if (glAttachShader != nullptr) {
            glAttachShader(program, shader);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glAttachShader returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glAttachShader\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glAttachShader\n");
        return false;
    }
}

bool callGlBindAttribLocation(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    uint32_t location = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindAttribLocation(%" PRIu32 ", %" PRIu32 ", %s)\n", program, location, name);
        if (glBindAttribLocation != nullptr) {
            glBindAttribLocation(program, location, name);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindAttribLocation returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindAttribLocation\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindAttribLocation\n");
        return false;
    }
}

bool callGlBindProgramPipeline(Stack* stack, bool pushReturn) {
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindProgramPipeline(%" PRIu32 ")\n", pipeline);
        if (glBindProgramPipeline != nullptr) {
            glBindProgramPipeline(pipeline);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindProgramPipeline returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindProgramPipeline\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindProgramPipeline\n");
        return false;
    }
}

bool callGlCompileShader(Stack* stack, bool pushReturn) {
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glCompileShader(%" PRIu32 ")\n", shader);
        if (glCompileShader != nullptr) {
            glCompileShader(shader);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCompileShader returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCompileShader\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCompileShader\n");
        return false;
    }
}

bool callGlCreateProgram(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glCreateProgram()\n");
        if (glCreateProgram != nullptr) {
            uint32_t return_value = glCreateProgram();
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCreateProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCreateProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCreateProgram\n");
        return false;
    }
}

bool callGlCreateShader(Stack* stack, bool pushReturn) {
    GLenum type = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCreateShader(%u)\n", type);
        if (glCreateShader != nullptr) {
            uint32_t return_value = glCreateShader(type);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCreateShader returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCreateShader\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCreateShader\n");
        return false;
    }
}

bool callGlCreateShaderProgramv(Stack* stack, bool pushReturn) {
    char** strings = stack->pop<char**>();
    int32_t count = stack->pop<int32_t>();
    GLenum type = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCreateShaderProgramv(%u, %" PRId32 ", %p)\n", type, count, strings);
        if (glCreateShaderProgramv != nullptr) {
            uint32_t return_value = glCreateShaderProgramv(type, count, strings);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCreateShaderProgramv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCreateShaderProgramv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCreateShaderProgramv\n");
        return false;
    }
}

bool callGlDeleteProgram(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteProgram(%" PRIu32 ")\n", program);
        if (glDeleteProgram != nullptr) {
            glDeleteProgram(program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteProgram\n");
        return false;
    }
}

bool callGlDeleteProgramPipelines(Stack* stack, bool pushReturn) {
    uint32_t* pipelines = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteProgramPipelines(%" PRId32 ", %p)\n", n, pipelines);
        if (glDeleteProgramPipelines != nullptr) {
            glDeleteProgramPipelines(n, pipelines);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteProgramPipelines returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteProgramPipelines\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteProgramPipelines\n");
        return false;
    }
}

bool callGlDeleteShader(Stack* stack, bool pushReturn) {
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteShader(%" PRIu32 ")\n", shader);
        if (glDeleteShader != nullptr) {
            glDeleteShader(shader);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteShader returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteShader\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteShader\n");
        return false;
    }
}

bool callGlDetachShader(Stack* stack, bool pushReturn) {
    uint32_t shader = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDetachShader(%" PRIu32 ", %" PRIu32 ")\n", program, shader);
        if (glDetachShader != nullptr) {
            glDetachShader(program, shader);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDetachShader returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDetachShader\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDetachShader\n");
        return false;
    }
}

bool callGlDispatchCompute(Stack* stack, bool pushReturn) {
    uint32_t num_groups_z = stack->pop<uint32_t>();
    uint32_t num_groups_y = stack->pop<uint32_t>();
    uint32_t num_groups_x = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDispatchCompute(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")\n", num_groups_x,
                   num_groups_y, num_groups_z);
        if (glDispatchCompute != nullptr) {
            glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDispatchCompute returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDispatchCompute\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDispatchCompute\n");
        return false;
    }
}

bool callGlDispatchComputeIndirect(Stack* stack, bool pushReturn) {
    int32_t indirect = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDispatchComputeIndirect(%" PRId32 ")\n", indirect);
        if (glDispatchComputeIndirect != nullptr) {
            glDispatchComputeIndirect(indirect);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDispatchComputeIndirect returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDispatchComputeIndirect\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDispatchComputeIndirect\n");
        return false;
    }
}

bool callGlGenProgramPipelines(Stack* stack, bool pushReturn) {
    uint32_t* pipelines = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenProgramPipelines(%" PRId32 ", %p)\n", n, pipelines);
        if (glGenProgramPipelines != nullptr) {
            glGenProgramPipelines(n, pipelines);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenProgramPipelines returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenProgramPipelines\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenProgramPipelines\n");
        return false;
    }
}

bool callGlGetActiveAttrib(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    GLenum* type = stack->pop<GLenum*>();
    int32_t* vector_count = stack->pop<int32_t*>();
    int32_t* buffer_bytes_written = stack->pop<int32_t*>();
    int32_t buffer_size = stack->pop<int32_t>();
    uint32_t location = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetActiveAttrib(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)\n",
                   program, location, buffer_size, buffer_bytes_written, vector_count, type, name);
        if (glGetActiveAttrib != nullptr) {
            glGetActiveAttrib(program, location, buffer_size, buffer_bytes_written, vector_count,
                              type, name);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetActiveAttrib returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetActiveAttrib\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetActiveAttrib\n");
        return false;
    }
}

bool callGlGetActiveUniform(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    GLenum* type = stack->pop<GLenum*>();
    int32_t* vector_count = stack->pop<int32_t*>();
    int32_t* buffer_bytes_written = stack->pop<int32_t*>();
    int32_t buffer_size = stack->pop<int32_t>();
    uint32_t location = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetActiveUniform(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p, %p, %p)\n",
                   program, location, buffer_size, buffer_bytes_written, vector_count, type, name);
        if (glGetActiveUniform != nullptr) {
            glGetActiveUniform(program, location, buffer_size, buffer_bytes_written, vector_count,
                               type, name);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetActiveUniform returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetActiveUniform\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetActiveUniform\n");
        return false;
    }
}

bool callGlGetActiveUniformBlockName(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    int32_t* buffer_bytes_written = stack->pop<int32_t*>();
    int32_t buffer_size = stack->pop<int32_t>();
    uint32_t uniform_block_index = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetActiveUniformBlockName(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %p, %p)\n",
                   program, uniform_block_index, buffer_size, buffer_bytes_written, name);
        if (glGetActiveUniformBlockName != nullptr) {
            glGetActiveUniformBlockName(program, uniform_block_index, buffer_size,
                                        buffer_bytes_written, name);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetActiveUniformBlockName returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformBlockName\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetActiveUniformBlockName\n");
        return false;
    }
}

bool callGlGetActiveUniformBlockiv(Stack* stack, bool pushReturn) {
    int32_t* parameters = stack->pop<int32_t*>();
    GLenum parameter_name = stack->pop<GLenum>();
    uint32_t uniform_block_index = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetActiveUniformBlockiv(%" PRIu32 ", %" PRIu32 ", %u, %p)\n", program,
                   uniform_block_index, parameter_name, parameters);
        if (glGetActiveUniformBlockiv != nullptr) {
            glGetActiveUniformBlockiv(program, uniform_block_index, parameter_name, parameters);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetActiveUniformBlockiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformBlockiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetActiveUniformBlockiv\n");
        return false;
    }
}

bool callGlGetActiveUniformsiv(Stack* stack, bool pushReturn) {
    int32_t* parameters = stack->pop<int32_t*>();
    GLenum parameter_name = stack->pop<GLenum>();
    uint32_t* uniform_indices = stack->pop<uint32_t*>();
    int32_t uniform_count = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetActiveUniformsiv(%" PRIu32 ", %" PRId32 ", %p, %u, %p)\n", program,
                   uniform_count, uniform_indices, parameter_name, parameters);
        if (glGetActiveUniformsiv != nullptr) {
            glGetActiveUniformsiv(program, uniform_count, uniform_indices, parameter_name,
                                  parameters);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetActiveUniformsiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetActiveUniformsiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetActiveUniformsiv\n");
        return false;
    }
}

bool callGlGetAttachedShaders(Stack* stack, bool pushReturn) {
    uint32_t* shaders = stack->pop<uint32_t*>();
    int32_t* shaders_length_written = stack->pop<int32_t*>();
    int32_t buffer_length = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetAttachedShaders(%" PRIu32 ", %" PRId32 ", %p, %p)\n", program,
                   buffer_length, shaders_length_written, shaders);
        if (glGetAttachedShaders != nullptr) {
            glGetAttachedShaders(program, buffer_length, shaders_length_written, shaders);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetAttachedShaders returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetAttachedShaders\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetAttachedShaders\n");
        return false;
    }
}

bool callGlGetAttribLocation(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetAttribLocation(%" PRIu32 ", %s)\n", program, name);
        if (glGetAttribLocation != nullptr) {
            int32_t return_value = glGetAttribLocation(program, name);
            GAPID_INFO("Returned: %" PRId32 "\n", return_value);
            if (pushReturn) {
                stack->push<int32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetAttribLocation returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetAttribLocation\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetAttribLocation\n");
        return false;
    }
}

bool callGlGetFragDataLocation(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFragDataLocation(%" PRIu32 ", %p)\n", program, name);
        if (glGetFragDataLocation != nullptr) {
            int32_t return_value = glGetFragDataLocation(program, name);
            GAPID_INFO("Returned: %" PRId32 "\n", return_value);
            if (pushReturn) {
                stack->push<int32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFragDataLocation returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFragDataLocation\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFragDataLocation\n");
        return false;
    }
}

bool callGlGetProgramBinary(Stack* stack, bool pushReturn) {
    void* binary = stack->pop<void*>();
    GLenum* binaryFormat = stack->pop<GLenum*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramBinary(%" PRIu32 ", %" PRId32 ", %p, %p, %p)\n", program, bufSize,
                   length, binaryFormat, binary);
        if (glGetProgramBinary != nullptr) {
            glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramBinary returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramBinary\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramBinary\n");
        return false;
    }
}

bool callGlGetProgramInfoLog(Stack* stack, bool pushReturn) {
    char* info = stack->pop<char*>();
    int32_t* string_length_written = stack->pop<int32_t*>();
    int32_t buffer_length = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)\n", program,
                   buffer_length, string_length_written, info);
        if (glGetProgramInfoLog != nullptr) {
            glGetProgramInfoLog(program, buffer_length, string_length_written, info);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramInfoLog returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramInfoLog\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramInfoLog\n");
        return false;
    }
}

bool callGlGetProgramInterfaceiv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum programInterface = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramInterfaceiv(%" PRIu32 ", %u, %u, %p)\n", program, programInterface,
                   pname, params);
        if (glGetProgramInterfaceiv != nullptr) {
            glGetProgramInterfaceiv(program, programInterface, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramInterfaceiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramInterfaceiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramInterfaceiv\n");
        return false;
    }
}

bool callGlGetProgramPipelineInfoLog(Stack* stack, bool pushReturn) {
    char* infoLog = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramPipelineInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)\n", pipeline,
                   bufSize, length, infoLog);
        if (glGetProgramPipelineInfoLog != nullptr) {
            glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramPipelineInfoLog returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineInfoLog\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramPipelineInfoLog\n");
        return false;
    }
}

bool callGlGetProgramPipelineiv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramPipelineiv(%" PRIu32 ", %u, %p)\n", pipeline, pname, params);
        if (glGetProgramPipelineiv != nullptr) {
            glGetProgramPipelineiv(pipeline, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramPipelineiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramPipelineiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramPipelineiv\n");
        return false;
    }
}

bool callGlGetProgramResourceIndex(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    GLenum programInterface = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramResourceIndex(%" PRIu32 ", %u, %p)\n", program, programInterface,
                   name);
        if (glGetProgramResourceIndex != nullptr) {
            uint32_t return_value = glGetProgramResourceIndex(program, programInterface, name);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramResourceIndex returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceIndex\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramResourceIndex\n");
        return false;
    }
}

bool callGlGetProgramResourceLocation(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    GLenum programInterface = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramResourceLocation(%" PRIu32 ", %u, %p)\n", program, programInterface,
                   name);
        if (glGetProgramResourceLocation != nullptr) {
            int32_t return_value = glGetProgramResourceLocation(program, programInterface, name);
            GAPID_INFO("Returned: %" PRId32 "\n", return_value);
            if (pushReturn) {
                stack->push<int32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramResourceLocation returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceLocation\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramResourceLocation\n");
        return false;
    }
}

bool callGlGetProgramResourceName(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum programInterface = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramResourceName(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %p)\n",
                   program, programInterface, index, bufSize, length, name);
        if (glGetProgramResourceName != nullptr) {
            glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramResourceName returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceName\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramResourceName\n");
        return false;
    }
}

bool callGlGetProgramResourceiv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    GLenum* props = stack->pop<GLenum*>();
    int32_t propCount = stack->pop<int32_t>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum programInterface = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramResourceiv(%" PRIu32 ", %u, %" PRIu32 ", %" PRId32 ", %p, %" PRId32
                   ", %p, %p)\n",
                   program, programInterface, index, propCount, props, bufSize, length, params);
        if (glGetProgramResourceiv != nullptr) {
            glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize,
                                   length, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramResourceiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramResourceiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramResourceiv\n");
        return false;
    }
}

bool callGlGetProgramiv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetProgramiv(%" PRIu32 ", %u, %p)\n", program, parameter, value);
        if (glGetProgramiv != nullptr) {
            glGetProgramiv(program, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetProgramiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetProgramiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetProgramiv\n");
        return false;
    }
}

bool callGlGetShaderInfoLog(Stack* stack, bool pushReturn) {
    char* info = stack->pop<char*>();
    int32_t* string_length_written = stack->pop<int32_t*>();
    int32_t buffer_length = stack->pop<int32_t>();
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetShaderInfoLog(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader, buffer_length,
                   string_length_written, info);
        if (glGetShaderInfoLog != nullptr) {
            glGetShaderInfoLog(shader, buffer_length, string_length_written, info);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetShaderInfoLog returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetShaderInfoLog\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetShaderInfoLog\n");
        return false;
    }
}

bool callGlGetShaderPrecisionFormat(Stack* stack, bool pushReturn) {
    int32_t* precision = stack->pop<int32_t*>();
    int32_t* range = stack->pop<int32_t*>();
    GLenum precision_type = stack->pop<GLenum>();
    GLenum shader_type = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetShaderPrecisionFormat(%u, %u, %p, %p)\n", shader_type, precision_type,
                   range, precision);
        if (glGetShaderPrecisionFormat != nullptr) {
            glGetShaderPrecisionFormat(shader_type, precision_type, range, precision);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetShaderPrecisionFormat returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetShaderPrecisionFormat\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetShaderPrecisionFormat\n");
        return false;
    }
}

bool callGlGetShaderSource(Stack* stack, bool pushReturn) {
    char* source = stack->pop<char*>();
    int32_t* string_length_written = stack->pop<int32_t*>();
    int32_t buffer_length = stack->pop<int32_t>();
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader, buffer_length,
                   string_length_written, source);
        if (glGetShaderSource != nullptr) {
            glGetShaderSource(shader, buffer_length, string_length_written, source);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetShaderSource returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetShaderSource\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetShaderSource\n");
        return false;
    }
}

bool callGlGetShaderiv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetShaderiv(%" PRIu32 ", %u, %p)\n", shader, parameter, value);
        if (glGetShaderiv != nullptr) {
            glGetShaderiv(shader, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetShaderiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetShaderiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetShaderiv\n");
        return false;
    }
}

bool callGlGetUniformBlockIndex(Stack* stack, bool pushReturn) {
    char* uniformBlockName = stack->pop<char*>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetUniformBlockIndex(%" PRIu32 ", %p)\n", program, uniformBlockName);
        if (glGetUniformBlockIndex != nullptr) {
            uint32_t return_value = glGetUniformBlockIndex(program, uniformBlockName);
            GAPID_INFO("Returned: %" PRIu32 "\n", return_value);
            if (pushReturn) {
                stack->push<uint32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetUniformBlockIndex returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetUniformBlockIndex\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetUniformBlockIndex\n");
        return false;
    }
}

bool callGlGetUniformIndices(Stack* stack, bool pushReturn) {
    uint32_t* uniformIndices = stack->pop<uint32_t*>();
    char** uniformNames = stack->pop<char**>();
    int32_t uniformCount = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetUniformIndices(%" PRIu32 ", %" PRId32 ", %p, %p)\n", program, uniformCount,
                   uniformNames, uniformIndices);
        if (glGetUniformIndices != nullptr) {
            glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetUniformIndices returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetUniformIndices\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetUniformIndices\n");
        return false;
    }
}

bool callGlGetUniformLocation(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetUniformLocation(%" PRIu32 ", %s)\n", program, name);
        if (glGetUniformLocation != nullptr) {
            int32_t return_value = glGetUniformLocation(program, name);
            GAPID_INFO("Returned: %" PRId32 "\n", return_value);
            if (pushReturn) {
                stack->push<int32_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetUniformLocation returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetUniformLocation\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetUniformLocation\n");
        return false;
    }
}

bool callGlGetUniformfv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetUniformfv(%" PRIu32 ", %" PRId32 ", %p)\n", program, location, values);
        if (glGetUniformfv != nullptr) {
            glGetUniformfv(program, location, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetUniformfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetUniformfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetUniformfv\n");
        return false;
    }
}

bool callGlGetUniformiv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetUniformiv(%" PRIu32 ", %" PRId32 ", %p)\n", program, location, values);
        if (glGetUniformiv != nullptr) {
            glGetUniformiv(program, location, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetUniformiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetUniformiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetUniformiv\n");
        return false;
    }
}

bool callGlGetUniformuiv(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetUniformuiv(%" PRIu32 ", %" PRId32 ", %p)\n", program, location, params);
        if (glGetUniformuiv != nullptr) {
            glGetUniformuiv(program, location, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetUniformuiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetUniformuiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetUniformuiv\n");
        return false;
    }
}

bool callGlIsProgram(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsProgram(%" PRIu32 ")\n", program);
        if (glIsProgram != nullptr) {
            bool return_value = glIsProgram(program);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsProgram\n");
        return false;
    }
}

bool callGlIsProgramPipeline(Stack* stack, bool pushReturn) {
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsProgramPipeline(%" PRIu32 ")\n", pipeline);
        if (glIsProgramPipeline != nullptr) {
            bool return_value = glIsProgramPipeline(pipeline);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsProgramPipeline returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsProgramPipeline\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsProgramPipeline\n");
        return false;
    }
}

bool callGlIsShader(Stack* stack, bool pushReturn) {
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsShader(%" PRIu32 ")\n", shader);
        if (glIsShader != nullptr) {
            bool return_value = glIsShader(shader);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsShader returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsShader\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsShader\n");
        return false;
    }
}

bool callGlLinkProgram(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glLinkProgram(%" PRIu32 ")\n", program);
        if (glLinkProgram != nullptr) {
            glLinkProgram(program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glLinkProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glLinkProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glLinkProgram\n");
        return false;
    }
}

bool callGlMemoryBarrier(Stack* stack, bool pushReturn) {
    GLbitfield barriers = stack->pop<GLbitfield>();
    if (stack->isValid()) {
        GAPID_INFO("glMemoryBarrier(%u)\n", barriers);
        if (glMemoryBarrier != nullptr) {
            glMemoryBarrier(barriers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMemoryBarrier returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMemoryBarrier\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMemoryBarrier\n");
        return false;
    }
}

bool callGlMemoryBarrierByRegion(Stack* stack, bool pushReturn) {
    GLbitfield barriers = stack->pop<GLbitfield>();
    if (stack->isValid()) {
        GAPID_INFO("glMemoryBarrierByRegion(%u)\n", barriers);
        if (glMemoryBarrierByRegion != nullptr) {
            glMemoryBarrierByRegion(barriers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glMemoryBarrierByRegion returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glMemoryBarrierByRegion\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glMemoryBarrierByRegion\n");
        return false;
    }
}

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

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

bool callGlProgramUniform1f(Stack* stack, bool pushReturn) {
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1f(%" PRIu32 ", %" PRId32 ", %f)\n", program, location, v0);
        if (glProgramUniform1f != nullptr) {
            glProgramUniform1f(program, location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1f\n");
        return false;
    }
}

bool callGlProgramUniform1fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform1fv != nullptr) {
            glProgramUniform1fv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1fv\n");
        return false;
    }
}

bool callGlProgramUniform1i(Stack* stack, bool pushReturn) {
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1i(%" PRIu32 ", %" PRId32 ", %" PRId32 ")\n", program, location,
                   v0);
        if (glProgramUniform1i != nullptr) {
            glProgramUniform1i(program, location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1i\n");
        return false;
    }
}

bool callGlProgramUniform1iv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform1iv != nullptr) {
            glProgramUniform1iv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1iv\n");
        return false;
    }
}

bool callGlProgramUniform1ui(Stack* stack, bool pushReturn) {
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ")\n", program,
                   location, v0);
        if (glProgramUniform1ui != nullptr) {
            glProgramUniform1ui(program, location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1ui\n");
        return false;
    }
}

bool callGlProgramUniform1uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform1uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform1uiv != nullptr) {
            glProgramUniform1uiv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform1uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform1uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform1uiv\n");
        return false;
    }
}

bool callGlProgramUniform2f(Stack* stack, bool pushReturn) {
    float v1 = stack->pop<float>();
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2f(%" PRIu32 ", %" PRId32 ", %f, %f)\n", program, location, v0,
                   v1);
        if (glProgramUniform2f != nullptr) {
            glProgramUniform2f(program, location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2f\n");
        return false;
    }
}

bool callGlProgramUniform2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform2fv != nullptr) {
            glProgramUniform2fv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2fv\n");
        return false;
    }
}

bool callGlProgramUniform2i(Stack* stack, bool pushReturn) {
    int32_t v1 = stack->pop<int32_t>();
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
                   program, location, v0, v1);
        if (glProgramUniform2i != nullptr) {
            glProgramUniform2i(program, location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2i\n");
        return false;
    }
}

bool callGlProgramUniform2iv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform2iv != nullptr) {
            glProgramUniform2iv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2iv\n");
        return false;
    }
}

bool callGlProgramUniform2ui(Stack* stack, bool pushReturn) {
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32 ")\n",
                   program, location, v0, v1);
        if (glProgramUniform2ui != nullptr) {
            glProgramUniform2ui(program, location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2ui\n");
        return false;
    }
}

bool callGlProgramUniform2uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform2uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform2uiv != nullptr) {
            glProgramUniform2uiv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform2uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform2uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform2uiv\n");
        return false;
    }
}

bool callGlProgramUniform3f(Stack* stack, bool pushReturn) {
    float v2 = stack->pop<float>();
    float v1 = stack->pop<float>();
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3f(%" PRIu32 ", %" PRId32 ", %f, %f, %f)\n", program, location,
                   v0, v1, v2);
        if (glProgramUniform3f != nullptr) {
            glProgramUniform3f(program, location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3f\n");
        return false;
    }
}

bool callGlProgramUniform3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform3fv != nullptr) {
            glProgramUniform3fv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3fv\n");
        return false;
    }
}

bool callGlProgramUniform3i(Stack* stack, bool pushReturn) {
    int32_t v2 = stack->pop<int32_t>();
    int32_t v1 = stack->pop<int32_t>();
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ")\n",
                   program, location, v0, v1, v2);
        if (glProgramUniform3i != nullptr) {
            glProgramUniform3i(program, location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3i\n");
        return false;
    }
}

bool callGlProgramUniform3iv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform3iv != nullptr) {
            glProgramUniform3iv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3iv\n");
        return false;
    }
}

bool callGlProgramUniform3ui(Stack* stack, bool pushReturn) {
    uint32_t v2 = stack->pop<uint32_t>();
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32
                   ", %" PRIu32 ")\n",
                   program, location, v0, v1, v2);
        if (glProgramUniform3ui != nullptr) {
            glProgramUniform3ui(program, location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3ui\n");
        return false;
    }
}

bool callGlProgramUniform3uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform3uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform3uiv != nullptr) {
            glProgramUniform3uiv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform3uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform3uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform3uiv\n");
        return false;
    }
}

bool callGlProgramUniform4f(Stack* stack, bool pushReturn) {
    float v3 = stack->pop<float>();
    float v2 = stack->pop<float>();
    float v1 = stack->pop<float>();
    float v0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4f(%" PRIu32 ", %" PRId32 ", %f, %f, %f, %f)\n", program,
                   location, v0, v1, v2, v3);
        if (glProgramUniform4f != nullptr) {
            glProgramUniform4f(program, location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4f\n");
        return false;
    }
}

bool callGlProgramUniform4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform4fv != nullptr) {
            glProgramUniform4fv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4fv\n");
        return false;
    }
}

bool callGlProgramUniform4i(Stack* stack, bool pushReturn) {
    int32_t v3 = stack->pop<int32_t>();
    int32_t v2 = stack->pop<int32_t>();
    int32_t v1 = stack->pop<int32_t>();
    int32_t v0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4i(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ")\n",
                   program, location, v0, v1, v2, v3);
        if (glProgramUniform4i != nullptr) {
            glProgramUniform4i(program, location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4i\n");
        return false;
    }
}

bool callGlProgramUniform4iv(Stack* stack, bool pushReturn) {
    int32_t* value = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4iv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform4iv != nullptr) {
            glProgramUniform4iv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4iv\n");
        return false;
    }
}

bool callGlProgramUniform4ui(Stack* stack, bool pushReturn) {
    uint32_t v3 = stack->pop<uint32_t>();
    uint32_t v2 = stack->pop<uint32_t>();
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4ui(%" PRIu32 ", %" PRId32 ", %" PRIu32 ", %" PRIu32
                   ", %" PRIu32 ", %" PRIu32 ")\n",
                   program, location, v0, v1, v2, v3);
        if (glProgramUniform4ui != nullptr) {
            glProgramUniform4ui(program, location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4ui\n");
        return false;
    }
}

bool callGlProgramUniform4uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniform4uiv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %p)\n", program,
                   location, count, value);
        if (glProgramUniform4uiv != nullptr) {
            glProgramUniform4uiv(program, location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniform4uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniform4uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniform4uiv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix2fv != nullptr) {
            glProgramUniformMatrix2fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix2fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix2x3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix2x3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix2x3fv != nullptr) {
            glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix2x3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2x3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix2x3fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix2x4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix2x4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix2x4fv != nullptr) {
            glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix2x4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix2x4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix2x4fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix3fv != nullptr) {
            glProgramUniformMatrix3fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix3fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix3x2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix3x2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix3x2fv != nullptr) {
            glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix3x2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3x2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix3x2fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix3x4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix3x4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix3x4fv != nullptr) {
            glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix3x4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix3x4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix3x4fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix4fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix4fv != nullptr) {
            glProgramUniformMatrix4fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix4fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix4x2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix4x2fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix4x2fv != nullptr) {
            glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix4x2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4x2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix4x2fv\n");
        return false;
    }
}

bool callGlProgramUniformMatrix4x3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glProgramUniformMatrix4x3fv(%" PRIu32 ", %" PRId32 ", %" PRId32 ", %" PRIu8
                   ", %p)\n",
                   program, location, count, transpose, value);
        if (glProgramUniformMatrix4x3fv != nullptr) {
            glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glProgramUniformMatrix4x3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glProgramUniformMatrix4x3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glProgramUniformMatrix4x3fv\n");
        return false;
    }
}

bool callGlReleaseShaderCompiler(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glReleaseShaderCompiler()\n");
        if (glReleaseShaderCompiler != nullptr) {
            glReleaseShaderCompiler();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glReleaseShaderCompiler returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glReleaseShaderCompiler\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glReleaseShaderCompiler\n");
        return false;
    }
}

bool callGlShaderBinary(Stack* stack, bool pushReturn) {
    int32_t binary_size = stack->pop<int32_t>();
    void* binary = stack->pop<void*>();
    GLenum binary_format = stack->pop<GLenum>();
    uint32_t* shaders = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glShaderBinary(%" PRId32 ", %p, %u, %p, %" PRId32 ")\n", count, shaders,
                   binary_format, binary, binary_size);
        if (glShaderBinary != nullptr) {
            glShaderBinary(count, shaders, binary_format, binary, binary_size);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glShaderBinary returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glShaderBinary\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glShaderBinary\n");
        return false;
    }
}

bool callGlShaderSource(Stack* stack, bool pushReturn) {
    int32_t* length = stack->pop<int32_t*>();
    char** source = stack->pop<char**>();
    int32_t count = stack->pop<int32_t>();
    uint32_t shader = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glShaderSource(%" PRIu32 ", %" PRId32 ", %p, %p)\n", shader, count, source,
                   length);
        if (glShaderSource != nullptr) {
            glShaderSource(shader, count, source, length);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glShaderSource returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glShaderSource\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glShaderSource\n");
        return false;
    }
}

bool callGlUniform1f(Stack* stack, bool pushReturn) {
    float value = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform1f(%" PRId32 ", %f)\n", location, value);
        if (glUniform1f != nullptr) {
            glUniform1f(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform1f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform1f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform1f\n");
        return false;
    }
}

bool callGlUniform1fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform1fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform1fv != nullptr) {
            glUniform1fv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform1fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform1fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform1fv\n");
        return false;
    }
}

bool callGlUniform1i(Stack* stack, bool pushReturn) {
    int32_t value = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform1i(%" PRId32 ", %" PRId32 ")\n", location, value);
        if (glUniform1i != nullptr) {
            glUniform1i(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform1i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform1i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform1i\n");
        return false;
    }
}

bool callGlUniform1iv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform1iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform1iv != nullptr) {
            glUniform1iv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform1iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform1iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform1iv\n");
        return false;
    }
}

bool callGlUniform1ui(Stack* stack, bool pushReturn) {
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform1ui(%" PRId32 ", %" PRIu32 ")\n", location, v0);
        if (glUniform1ui != nullptr) {
            glUniform1ui(location, v0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform1ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform1ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform1ui\n");
        return false;
    }
}

bool callGlUniform1uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform1uiv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, value);
        if (glUniform1uiv != nullptr) {
            glUniform1uiv(location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform1uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform1uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform1uiv\n");
        return false;
    }
}

bool callGlUniform2f(Stack* stack, bool pushReturn) {
    float value1 = stack->pop<float>();
    float value0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2f(%" PRId32 ", %f, %f)\n", location, value0, value1);
        if (glUniform2f != nullptr) {
            glUniform2f(location, value0, value1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform2f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2f\n");
        return false;
    }
}

bool callGlUniform2fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform2fv != nullptr) {
            glUniform2fv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2fv\n");
        return false;
    }
}

bool callGlUniform2i(Stack* stack, bool pushReturn) {
    int32_t value1 = stack->pop<int32_t>();
    int32_t value0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2i(%" PRId32 ", %" PRId32 ", %" PRId32 ")\n", location, value0,
                   value1);
        if (glUniform2i != nullptr) {
            glUniform2i(location, value0, value1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform2i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2i\n");
        return false;
    }
}

bool callGlUniform2iv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform2iv != nullptr) {
            glUniform2iv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform2iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2iv\n");
        return false;
    }
}

bool callGlUniform2ui(Stack* stack, bool pushReturn) {
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ")\n", location, v0, v1);
        if (glUniform2ui != nullptr) {
            glUniform2ui(location, v0, v1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform2ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2ui\n");
        return false;
    }
}

bool callGlUniform2uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform2uiv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, value);
        if (glUniform2uiv != nullptr) {
            glUniform2uiv(location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform2uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform2uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform2uiv\n");
        return false;
    }
}

bool callGlUniform3f(Stack* stack, bool pushReturn) {
    float value2 = stack->pop<float>();
    float value1 = stack->pop<float>();
    float value0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform3f(%" PRId32 ", %f, %f, %f)\n", location, value0, value1, value2);
        if (glUniform3f != nullptr) {
            glUniform3f(location, value0, value1, value2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform3f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform3f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform3f\n");
        return false;
    }
}

bool callGlUniform3fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform3fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform3fv != nullptr) {
            glUniform3fv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform3fv\n");
        return false;
    }
}

bool callGlUniform3i(Stack* stack, bool pushReturn) {
    int32_t value2 = stack->pop<int32_t>();
    int32_t value1 = stack->pop<int32_t>();
    int32_t value0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform3i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", location,
                   value0, value1, value2);
        if (glUniform3i != nullptr) {
            glUniform3i(location, value0, value1, value2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform3i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform3i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform3i\n");
        return false;
    }
}

bool callGlUniform3iv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform3iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform3iv != nullptr) {
            glUniform3iv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform3iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform3iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform3iv\n");
        return false;
    }
}

bool callGlUniform3ui(Stack* stack, bool pushReturn) {
    uint32_t v2 = stack->pop<uint32_t>();
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform3ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ")\n", location,
                   v0, v1, v2);
        if (glUniform3ui != nullptr) {
            glUniform3ui(location, v0, v1, v2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform3ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform3ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform3ui\n");
        return false;
    }
}

bool callGlUniform3uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform3uiv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, value);
        if (glUniform3uiv != nullptr) {
            glUniform3uiv(location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform3uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform3uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform3uiv\n");
        return false;
    }
}

bool callGlUniform4f(Stack* stack, bool pushReturn) {
    float value3 = stack->pop<float>();
    float value2 = stack->pop<float>();
    float value1 = stack->pop<float>();
    float value0 = stack->pop<float>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4f(%" PRId32 ", %f, %f, %f, %f)\n", location, value0, value1, value2,
                   value3);
        if (glUniform4f != nullptr) {
            glUniform4f(location, value0, value1, value2, value3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform4f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4f\n");
        return false;
    }
}

bool callGlUniform4fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4fv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform4fv != nullptr) {
            glUniform4fv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4fv\n");
        return false;
    }
}

bool callGlUniform4i(Stack* stack, bool pushReturn) {
    int32_t value3 = stack->pop<int32_t>();
    int32_t value2 = stack->pop<int32_t>();
    int32_t value1 = stack->pop<int32_t>();
    int32_t value0 = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4i(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n",
                   location, value0, value1, value2, value3);
        if (glUniform4i != nullptr) {
            glUniform4i(location, value0, value1, value2, value3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform4i returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4i\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4i\n");
        return false;
    }
}

bool callGlUniform4iv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4iv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, values);
        if (glUniform4iv != nullptr) {
            glUniform4iv(location, count, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform4iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4iv\n");
        return false;
    }
}

bool callGlUniform4ui(Stack* stack, bool pushReturn) {
    uint32_t v3 = stack->pop<uint32_t>();
    uint32_t v2 = stack->pop<uint32_t>();
    uint32_t v1 = stack->pop<uint32_t>();
    uint32_t v0 = stack->pop<uint32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4ui(%" PRId32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32
                   ")\n",
                   location, v0, v1, v2, v3);
        if (glUniform4ui != nullptr) {
            glUniform4ui(location, v0, v1, v2, v3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform4ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4ui\n");
        return false;
    }
}

bool callGlUniform4uiv(Stack* stack, bool pushReturn) {
    uint32_t* value = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniform4uiv(%" PRId32 ", %" PRId32 ", %p)\n", location, count, value);
        if (glUniform4uiv != nullptr) {
            glUniform4uiv(location, count, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniform4uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniform4uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniform4uiv\n");
        return false;
    }
}

bool callGlUniformBlockBinding(Stack* stack, bool pushReturn) {
    uint32_t uniform_block_binding = stack->pop<uint32_t>();
    uint32_t uniform_block_index = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformBlockBinding(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")\n", program,
                   uniform_block_index, uniform_block_binding);
        if (glUniformBlockBinding != nullptr) {
            glUniformBlockBinding(program, uniform_block_index, uniform_block_binding);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformBlockBinding returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformBlockBinding\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformBlockBinding\n");
        return false;
    }
}

bool callGlUniformMatrix2fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, values);
        if (glUniformMatrix2fv != nullptr) {
            glUniformMatrix2fv(location, count, transpose, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix2fv\n");
        return false;
    }
}

bool callGlUniformMatrix2x3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix2x3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix2x3fv != nullptr) {
            glUniformMatrix2x3fv(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix2x3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix2x3fv\n");
        return false;
    }
}

bool callGlUniformMatrix2x4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix2x4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix2x4fv != nullptr) {
            glUniformMatrix2x4fv(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix2x4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix2x4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix2x4fv\n");
        return false;
    }
}

bool callGlUniformMatrix3fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, values);
        if (glUniformMatrix3fv != nullptr) {
            glUniformMatrix3fv(location, count, transpose, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix3fv\n");
        return false;
    }
}

bool callGlUniformMatrix3x2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix3x2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix3x2fv != nullptr) {
            glUniformMatrix3x2fv(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix3x2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix3x2fv\n");
        return false;
    }
}

bool callGlUniformMatrix3x4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix3x4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix3x4fv != nullptr) {
            glUniformMatrix3x4fv(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix3x4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix3x4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix3x4fv\n");
        return false;
    }
}

bool callGlUniformMatrix4fv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix4fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, values);
        if (glUniformMatrix4fv != nullptr) {
            glUniformMatrix4fv(location, count, transpose, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix4fv\n");
        return false;
    }
}

bool callGlUniformMatrix4x2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix4x2fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix4x2fv != nullptr) {
            glUniformMatrix4x2fv(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix4x2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix4x2fv\n");
        return false;
    }
}

bool callGlUniformMatrix4x3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint8_t transpose = stack->pop<uint8_t>();
    int32_t count = stack->pop<int32_t>();
    int32_t location = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUniformMatrix4x3fv(%" PRId32 ", %" PRId32 ", %" PRIu8 ", %p)\n", location,
                   count, transpose, value);
        if (glUniformMatrix4x3fv != nullptr) {
            glUniformMatrix4x3fv(location, count, transpose, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUniformMatrix4x3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUniformMatrix4x3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUniformMatrix4x3fv\n");
        return false;
    }
}

bool callGlUseProgram(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUseProgram(%" PRIu32 ")\n", program);
        if (glUseProgram != nullptr) {
            glUseProgram(program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUseProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUseProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUseProgram\n");
        return false;
    }
}

bool callGlUseProgramStages(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    GLbitfield stages = stack->pop<GLbitfield>();
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glUseProgramStages(%" PRIu32 ", %u, %" PRIu32 ")\n", pipeline, stages, program);
        if (glUseProgramStages != nullptr) {
            glUseProgramStages(pipeline, stages, program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glUseProgramStages returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glUseProgramStages\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glUseProgramStages\n");
        return false;
    }
}

bool callGlValidateProgram(Stack* stack, bool pushReturn) {
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glValidateProgram(%" PRIu32 ")\n", program);
        if (glValidateProgram != nullptr) {
            glValidateProgram(program);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glValidateProgram returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glValidateProgram\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glValidateProgram\n");
        return false;
    }
}

bool callGlValidateProgramPipeline(Stack* stack, bool pushReturn) {
    uint32_t pipeline = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glValidateProgramPipeline(%" PRIu32 ")\n", pipeline);
        if (glValidateProgramPipeline != nullptr) {
            glValidateProgramPipeline(pipeline);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glValidateProgramPipeline returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glValidateProgramPipeline\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glValidateProgramPipeline\n");
        return false;
    }
}

bool callGlCullFace(Stack* stack, bool pushReturn) {
    GLenum mode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCullFace(%u)\n", mode);
        if (glCullFace != nullptr) {
            glCullFace(mode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCullFace returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCullFace\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCullFace\n");
        return false;
    }
}

bool callGlDepthRangef(Stack* stack, bool pushReturn) {
    float far = stack->pop<float>();
    float near = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glDepthRangef(%f, %f)\n", near, far);
        if (glDepthRangef != nullptr) {
            glDepthRangef(near, far);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDepthRangef returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDepthRangef\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDepthRangef\n");
        return false;
    }
}

bool callGlFrontFace(Stack* stack, bool pushReturn) {
    GLenum orientation = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFrontFace(%u)\n", orientation);
        if (glFrontFace != nullptr) {
            glFrontFace(orientation);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFrontFace returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFrontFace\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFrontFace\n");
        return false;
    }
}

bool callGlGetMultisamplefv(Stack* stack, bool pushReturn) {
    float* val = stack->pop<float*>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetMultisamplefv(%u, %" PRIu32 ", %p)\n", pname, index, val);
        if (glGetMultisamplefv != nullptr) {
            glGetMultisamplefv(pname, index, val);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetMultisamplefv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetMultisamplefv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetMultisamplefv\n");
        return false;
    }
}

bool callGlLineWidth(Stack* stack, bool pushReturn) {
    float width = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glLineWidth(%f)\n", width);
        if (glLineWidth != nullptr) {
            glLineWidth(width);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glLineWidth returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glLineWidth\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glLineWidth\n");
        return false;
    }
}

bool callGlPolygonOffset(Stack* stack, bool pushReturn) {
    float units = stack->pop<float>();
    float scale_factor = stack->pop<float>();
    if (stack->isValid()) {
        GAPID_INFO("glPolygonOffset(%f, %f)\n", scale_factor, units);
        if (glPolygonOffset != nullptr) {
            glPolygonOffset(scale_factor, units);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPolygonOffset returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPolygonOffset\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPolygonOffset\n");
        return false;
    }
}

bool callGlViewport(Stack* stack, bool pushReturn) {
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t y = stack->pop<int32_t>();
    int32_t x = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glViewport(%" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ")\n", x, y, width,
                   height);
        if (glViewport != nullptr) {
            glViewport(x, y, width, height);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glViewport returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glViewport\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glViewport\n");
        return false;
    }
}

bool callGlGetBooleaniV(Stack* stack, bool pushReturn) {
    uint8_t* data = stack->pop<uint8_t*>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetBooleani_v(%u, %" PRIu32 ", %p)\n", target, index, data);
        if (glGetBooleani_v != nullptr) {
            glGetBooleani_v(target, index, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetBooleani_v returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetBooleani_v\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetBooleani_v\n");
        return false;
    }
}

bool callGlGetBooleanv(Stack* stack, bool pushReturn) {
    bool* values = stack->pop<bool*>();
    GLenum param = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetBooleanv(%u, %p)\n", param, values);
        if (glGetBooleanv != nullptr) {
            glGetBooleanv(param, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetBooleanv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetBooleanv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetBooleanv\n");
        return false;
    }
}

bool callGlGetFloatv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    GLenum param = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetFloatv(%u, %p)\n", param, values);
        if (glGetFloatv != nullptr) {
            glGetFloatv(param, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetFloatv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetFloatv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetFloatv\n");
        return false;
    }
}

bool callGlGetInteger64iV(Stack* stack, bool pushReturn) {
    int64_t* data = stack->pop<int64_t*>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetInteger64i_v(%u, %" PRIu32 ", %p)\n", target, index, data);
        if (glGetInteger64i_v != nullptr) {
            glGetInteger64i_v(target, index, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetInteger64i_v returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetInteger64i_v\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetInteger64i_v\n");
        return false;
    }
}

bool callGlGetInteger64v(Stack* stack, bool pushReturn) {
    int64_t* data = stack->pop<int64_t*>();
    GLenum pname = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetInteger64v(%u, %p)\n", pname, data);
        if (glGetInteger64v != nullptr) {
            glGetInteger64v(pname, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetInteger64v returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetInteger64v\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetInteger64v\n");
        return false;
    }
}

bool callGlGetIntegeriV(Stack* stack, bool pushReturn) {
    int32_t* data = stack->pop<int32_t*>();
    uint32_t index = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetIntegeri_v(%u, %" PRIu32 ", %p)\n", target, index, data);
        if (glGetIntegeri_v != nullptr) {
            glGetIntegeri_v(target, index, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetIntegeri_v returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetIntegeri_v\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetIntegeri_v\n");
        return false;
    }
}

bool callGlGetIntegerv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    GLenum param = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetIntegerv(%u, %p)\n", param, values);
        if (glGetIntegerv != nullptr) {
            glGetIntegerv(param, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetIntegerv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetIntegerv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetIntegerv\n");
        return false;
    }
}

bool callGlGetInternalformativ(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    GLenum internalformat = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetInternalformativ(%u, %u, %u, %" PRId32 ", %p)\n", target, internalformat,
                   pname, bufSize, params);
        if (glGetInternalformativ != nullptr) {
            glGetInternalformativ(target, internalformat, pname, bufSize, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetInternalformativ returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetInternalformativ\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetInternalformativ\n");
        return false;
    }
}

bool callGlGetString(Stack* stack, bool pushReturn) {
    GLenum param = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetString(%u)\n", param);
        if (glGetString != nullptr) {
            uint8_t* return_value = glGetString(param);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetString returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetString\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetString\n");
        return false;
    }
}

bool callGlGetStringi(Stack* stack, bool pushReturn) {
    uint32_t index = stack->pop<uint32_t>();
    GLenum name = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetStringi(%u, %" PRIu32 ")\n", name, index);
        if (glGetStringi != nullptr) {
            uint8_t* return_value = glGetStringi(name, index);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<uint8_t*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetStringi returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetStringi\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetStringi\n");
        return false;
    }
}

bool callGlIsEnabled(Stack* stack, bool pushReturn) {
    GLenum capability = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glIsEnabled(%u)\n", capability);
        if (glIsEnabled != nullptr) {
            bool return_value = glIsEnabled(capability);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsEnabled returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsEnabled\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsEnabled\n");
        return false;
    }
}

bool callGlClientWaitSync(Stack* stack, bool pushReturn) {
    uint64_t timeout = stack->pop<uint64_t>();
    GLbitfield syncFlags = stack->pop<GLbitfield>();
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glClientWaitSync(%" PRIu64 ", %u, %" PRIu64 ")\n", sync, syncFlags, timeout);
        if (glClientWaitSync != nullptr) {
            GLenum return_value = glClientWaitSync(sync, syncFlags, timeout);
            GAPID_INFO("Returned: %u\n", return_value);
            if (pushReturn) {
                stack->push<GLenum>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glClientWaitSync returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glClientWaitSync\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glClientWaitSync\n");
        return false;
    }
}

bool callGlDeleteSync(Stack* stack, bool pushReturn) {
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteSync(%" PRIu64 ")\n", sync);
        if (glDeleteSync != nullptr) {
            glDeleteSync(sync);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteSync returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteSync\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteSync\n");
        return false;
    }
}

bool callGlFenceSync(Stack* stack, bool pushReturn) {
    GLbitfield syncFlags = stack->pop<GLbitfield>();
    GLenum condition = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glFenceSync(%u, %u)\n", condition, syncFlags);
        if (glFenceSync != nullptr) {
            uint64_t return_value = glFenceSync(condition, syncFlags);
            GAPID_INFO("Returned: %" PRIu64 "\n", return_value);
            if (pushReturn) {
                stack->push<uint64_t>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glFenceSync returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glFenceSync\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glFenceSync\n");
        return false;
    }
}

bool callGlGetSynciv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    GLenum pname = stack->pop<GLenum>();
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSynciv(%" PRIu64 ", %u, %" PRId32 ", %p, %p)\n", sync, pname, bufSize,
                   length, values);
        if (glGetSynciv != nullptr) {
            glGetSynciv(sync, pname, bufSize, length, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSynciv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSynciv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSynciv\n");
        return false;
    }
}

bool callGlIsSync(Stack* stack, bool pushReturn) {
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsSync(%" PRIu64 ")\n", sync);
        if (glIsSync != nullptr) {
            bool return_value = glIsSync(sync);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsSync returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsSync\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsSync\n");
        return false;
    }
}

bool callGlWaitSync(Stack* stack, bool pushReturn) {
    uint64_t timeout = stack->pop<uint64_t>();
    GLbitfield syncFlags = stack->pop<GLbitfield>();
    uint64_t sync = stack->pop<uint64_t>();
    if (stack->isValid()) {
        GAPID_INFO("glWaitSync(%" PRIu64 ", %u, %" PRIu64 ")\n", sync, syncFlags, timeout);
        if (glWaitSync != nullptr) {
            glWaitSync(sync, syncFlags, timeout);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glWaitSync returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glWaitSync\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glWaitSync\n");
        return false;
    }
}

bool callGlActiveTexture(Stack* stack, bool pushReturn) {
    GLenum unit = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glActiveTexture(%u)\n", unit);
        if (glActiveTexture != nullptr) {
            glActiveTexture(unit);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glActiveTexture returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glActiveTexture\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glActiveTexture\n");
        return false;
    }
}

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

bool callGlBindSampler(Stack* stack, bool pushReturn) {
    uint32_t sampler = stack->pop<uint32_t>();
    uint32_t unit = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindSampler(%" PRIu32 ", %" PRIu32 ")\n", unit, sampler);
        if (glBindSampler != nullptr) {
            glBindSampler(unit, sampler);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindSampler returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindSampler\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindSampler\n");
        return false;
    }
}

bool callGlBindTexture(Stack* stack, bool pushReturn) {
    uint32_t texture = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBindTexture(%u, %" PRIu32 ")\n", target, texture);
        if (glBindTexture != nullptr) {
            glBindTexture(target, texture);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindTexture returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindTexture\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindTexture\n");
        return false;
    }
}

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

bool callGlCompressedTexImage3D(Stack* stack, bool pushReturn) {
    void* data = stack->pop<void*>();
    int32_t imageSize = stack->pop<int32_t>();
    int32_t border = stack->pop<int32_t>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    GLenum internalformat = stack->pop<GLenum>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCompressedTexImage3D(%u, %" PRId32 ", %u, %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ", %p)\n",
                   target, level, internalformat, width, height, depth, border, imageSize, data);
        if (glCompressedTexImage3D != nullptr) {
            glCompressedTexImage3D(target, level, internalformat, width, height, depth, border,
                                   imageSize, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCompressedTexImage3D returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCompressedTexImage3D\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCompressedTexImage3D\n");
        return false;
    }
}

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

bool callGlCompressedTexSubImage3D(Stack* stack, bool pushReturn) {
    void* data = stack->pop<void*>();
    int32_t imageSize = stack->pop<int32_t>();
    GLenum format = stack->pop<GLenum>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t zoffset = stack->pop<int32_t>();
    int32_t yoffset = stack->pop<int32_t>();
    int32_t xoffset = stack->pop<int32_t>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glCompressedTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %" PRId32 ", %p)\n",
                   target, level, xoffset, yoffset, zoffset, width, height, depth, format,
                   imageSize, data);
        if (glCompressedTexSubImage3D != nullptr) {
            glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
                                      depth, format, imageSize, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glCompressedTexSubImage3D returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glCompressedTexSubImage3D\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glCompressedTexSubImage3D\n");
        return false;
    }
}

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

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

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

bool callGlDeleteSamplers(Stack* stack, bool pushReturn) {
    uint32_t* samplers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteSamplers(%" PRId32 ", %p)\n", count, samplers);
        if (glDeleteSamplers != nullptr) {
            glDeleteSamplers(count, samplers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteSamplers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteSamplers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteSamplers\n");
        return false;
    }
}

bool callGlDeleteTextures(Stack* stack, bool pushReturn) {
    uint32_t* textures = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteTextures(%" PRId32 ", %p)\n", count, textures);
        if (glDeleteTextures != nullptr) {
            glDeleteTextures(count, textures);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteTextures returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteTextures\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteTextures\n");
        return false;
    }
}

bool callGlGenSamplers(Stack* stack, bool pushReturn) {
    uint32_t* samplers = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenSamplers(%" PRId32 ", %p)\n", count, samplers);
        if (glGenSamplers != nullptr) {
            glGenSamplers(count, samplers);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenSamplers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenSamplers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenSamplers\n");
        return false;
    }
}

bool callGlGenTextures(Stack* stack, bool pushReturn) {
    uint32_t* textures = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenTextures(%" PRId32 ", %p)\n", count, textures);
        if (glGenTextures != nullptr) {
            glGenTextures(count, textures);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenTextures returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenTextures\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenTextures\n");
        return false;
    }
}

bool callGlGenerateMipmap(Stack* stack, bool pushReturn) {
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGenerateMipmap(%u)\n", target);
        if (glGenerateMipmap != nullptr) {
            glGenerateMipmap(target);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenerateMipmap returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenerateMipmap\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenerateMipmap\n");
        return false;
    }
}

bool callGlGetSamplerParameterfv(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSamplerParameterfv(%" PRIu32 ", %u, %p)\n", sampler, pname, params);
        if (glGetSamplerParameterfv != nullptr) {
            glGetSamplerParameterfv(sampler, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSamplerParameterfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameterfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSamplerParameterfv\n");
        return false;
    }
}

bool callGlGetSamplerParameteriv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetSamplerParameteriv(%" PRIu32 ", %u, %p)\n", sampler, pname, params);
        if (glGetSamplerParameteriv != nullptr) {
            glGetSamplerParameteriv(sampler, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetSamplerParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetSamplerParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetSamplerParameteriv\n");
        return false;
    }
}

bool callGlGetTexLevelParameterfv(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexLevelParameterfv(%u, %" PRId32 ", %u, %p)\n", target, level, pname,
                   params);
        if (glGetTexLevelParameterfv != nullptr) {
            glGetTexLevelParameterfv(target, level, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexLevelParameterfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexLevelParameterfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexLevelParameterfv\n");
        return false;
    }
}

bool callGlGetTexLevelParameteriv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexLevelParameteriv(%u, %" PRId32 ", %u, %p)\n", target, level, pname,
                   params);
        if (glGetTexLevelParameteriv != nullptr) {
            glGetTexLevelParameteriv(target, level, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexLevelParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexLevelParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexLevelParameteriv\n");
        return false;
    }
}

bool callGlGetTexParameterfv(Stack* stack, bool pushReturn) {
    float* values = stack->pop<float*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexParameterfv(%u, %u, %p)\n", target, parameter, values);
        if (glGetTexParameterfv != nullptr) {
            glGetTexParameterfv(target, parameter, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexParameterfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexParameterfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexParameterfv\n");
        return false;
    }
}

bool callGlGetTexParameteriv(Stack* stack, bool pushReturn) {
    int32_t* values = stack->pop<int32_t*>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTexParameteriv(%u, %u, %p)\n", target, parameter, values);
        if (glGetTexParameteriv != nullptr) {
            glGetTexParameteriv(target, parameter, values);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTexParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTexParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTexParameteriv\n");
        return false;
    }
}

bool callGlIsSampler(Stack* stack, bool pushReturn) {
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsSampler(%" PRIu32 ")\n", sampler);
        if (glIsSampler != nullptr) {
            bool return_value = glIsSampler(sampler);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsSampler returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsSampler\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsSampler\n");
        return false;
    }
}

bool callGlIsTexture(Stack* stack, bool pushReturn) {
    uint32_t texture = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsTexture(%" PRIu32 ")\n", texture);
        if (glIsTexture != nullptr) {
            bool return_value = glIsTexture(texture);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsTexture returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsTexture\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsTexture\n");
        return false;
    }
}

bool callGlPixelStorei(Stack* stack, bool pushReturn) {
    int32_t value = stack->pop<int32_t>();
    GLenum parameter = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glPixelStorei(%u, %" PRId32 ")\n", parameter, value);
        if (glPixelStorei != nullptr) {
            glPixelStorei(parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPixelStorei returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPixelStorei\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPixelStorei\n");
        return false;
    }
}

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

bool callGlSamplerParameterfv(Stack* stack, bool pushReturn) {
    float* param = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSamplerParameterfv(%" PRIu32 ", %u, %p)\n", sampler, pname, param);
        if (glSamplerParameterfv != nullptr) {
            glSamplerParameterfv(sampler, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSamplerParameterfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSamplerParameterfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSamplerParameterfv\n");
        return false;
    }
}

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

bool callGlSamplerParameteriv(Stack* stack, bool pushReturn) {
    int32_t* param = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t sampler = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glSamplerParameteriv(%" PRIu32 ", %u, %p)\n", sampler, pname, param);
        if (glSamplerParameteriv != nullptr) {
            glSamplerParameteriv(sampler, pname, param);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glSamplerParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glSamplerParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glSamplerParameteriv\n");
        return false;
    }
}

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

bool callGlTexImage3D(Stack* stack, bool pushReturn) {
    void* pixels = stack->pop<void*>();
    GLenum type = stack->pop<GLenum>();
    GLenum format = stack->pop<GLenum>();
    int32_t border = stack->pop<int32_t>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t internalformat = stack->pop<int32_t>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %u, %u, %p)\n",
                   target, level, internalformat, width, height, depth, border, format, type,
                   pixels);
        if (glTexImage3D != nullptr) {
            glTexImage3D(target, level, internalformat, width, height, depth, border, format, type,
                         pixels);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexImage3D returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexImage3D\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexImage3D\n");
        return false;
    }
}

bool callGlTexParameterf(Stack* stack, bool pushReturn) {
    float value = stack->pop<float>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameterf(%u, %u, %f)\n", target, parameter, value);
        if (glTexParameterf != nullptr) {
            glTexParameterf(target, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameterf returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameterf\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameterf\n");
        return false;
    }
}

bool callGlTexParameterfv(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameterfv(%u, %u, %p)\n", target, pname, params);
        if (glTexParameterfv != nullptr) {
            glTexParameterfv(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameterfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameterfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameterfv\n");
        return false;
    }
}

bool callGlTexParameteri(Stack* stack, bool pushReturn) {
    int32_t value = stack->pop<int32_t>();
    GLenum parameter = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameteri(%u, %u, %" PRId32 ")\n", target, parameter, value);
        if (glTexParameteri != nullptr) {
            glTexParameteri(target, parameter, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameteri returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameteri\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameteri\n");
        return false;
    }
}

bool callGlTexParameteriv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexParameteriv(%u, %u, %p)\n", target, pname, params);
        if (glTexParameteriv != nullptr) {
            glTexParameteriv(target, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexParameteriv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexParameteriv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexParameteriv\n");
        return false;
    }
}

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

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

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

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

bool callGlTexSubImage3D(Stack* stack, bool pushReturn) {
    void* pixels = stack->pop<void*>();
    GLenum type = stack->pop<GLenum>();
    GLenum format = stack->pop<GLenum>();
    int32_t depth = stack->pop<int32_t>();
    int32_t height = stack->pop<int32_t>();
    int32_t width = stack->pop<int32_t>();
    int32_t zoffset = stack->pop<int32_t>();
    int32_t yoffset = stack->pop<int32_t>();
    int32_t xoffset = stack->pop<int32_t>();
    int32_t level = stack->pop<int32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glTexSubImage3D(%u, %" PRId32 ", %" PRId32 ", %" PRId32 ", %" PRId32
                   ", %" PRId32 ", %" PRId32 ", %" PRId32 ", %u, %u, %p)\n",
                   target, level, xoffset, yoffset, zoffset, width, height, depth, format, type,
                   pixels);
        if (glTexSubImage3D != nullptr) {
            glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format,
                            type, pixels);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTexSubImage3D returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTexSubImage3D\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTexSubImage3D\n");
        return false;
    }
}

bool callGlBeginTransformFeedback(Stack* stack, bool pushReturn) {
    GLenum primitiveMode = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBeginTransformFeedback(%u)\n", primitiveMode);
        if (glBeginTransformFeedback != nullptr) {
            glBeginTransformFeedback(primitiveMode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBeginTransformFeedback returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBeginTransformFeedback\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBeginTransformFeedback\n");
        return false;
    }
}

bool callGlBindTransformFeedback(Stack* stack, bool pushReturn) {
    uint32_t id = stack->pop<uint32_t>();
    GLenum target = stack->pop<GLenum>();
    if (stack->isValid()) {
        GAPID_INFO("glBindTransformFeedback(%u, %" PRIu32 ")\n", target, id);
        if (glBindTransformFeedback != nullptr) {
            glBindTransformFeedback(target, id);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindTransformFeedback returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindTransformFeedback\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindTransformFeedback\n");
        return false;
    }
}

bool callGlDeleteTransformFeedbacks(Stack* stack, bool pushReturn) {
    uint32_t* ids = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteTransformFeedbacks(%" PRId32 ", %p)\n", n, ids);
        if (glDeleteTransformFeedbacks != nullptr) {
            glDeleteTransformFeedbacks(n, ids);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteTransformFeedbacks returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteTransformFeedbacks\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteTransformFeedbacks\n");
        return false;
    }
}

bool callGlEndTransformFeedback(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glEndTransformFeedback()\n");
        if (glEndTransformFeedback != nullptr) {
            glEndTransformFeedback();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEndTransformFeedback returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEndTransformFeedback\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEndTransformFeedback\n");
        return false;
    }
}

bool callGlGenTransformFeedbacks(Stack* stack, bool pushReturn) {
    uint32_t* ids = stack->pop<uint32_t*>();
    int32_t n = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenTransformFeedbacks(%" PRId32 ", %p)\n", n, ids);
        if (glGenTransformFeedbacks != nullptr) {
            glGenTransformFeedbacks(n, ids);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenTransformFeedbacks returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenTransformFeedbacks\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenTransformFeedbacks\n");
        return false;
    }
}

bool callGlGetTransformFeedbackVarying(Stack* stack, bool pushReturn) {
    char* name = stack->pop<char*>();
    GLenum* type = stack->pop<GLenum*>();
    int32_t* size = stack->pop<int32_t*>();
    int32_t* length = stack->pop<int32_t*>();
    int32_t bufSize = stack->pop<int32_t>();
    uint32_t index = stack->pop<uint32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetTransformFeedbackVarying(%" PRIu32 ", %" PRIu32 ", %" PRId32
                   ", %p, %p, %p, %p)\n",
                   program, index, bufSize, length, size, type, name);
        if (glGetTransformFeedbackVarying != nullptr) {
            glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetTransformFeedbackVarying returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetTransformFeedbackVarying\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetTransformFeedbackVarying\n");
        return false;
    }
}

bool callGlIsTransformFeedback(Stack* stack, bool pushReturn) {
    uint32_t id = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsTransformFeedback(%" PRIu32 ")\n", id);
        if (glIsTransformFeedback != nullptr) {
            bool return_value = glIsTransformFeedback(id);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsTransformFeedback returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsTransformFeedback\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsTransformFeedback\n");
        return false;
    }
}

bool callGlPauseTransformFeedback(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glPauseTransformFeedback()\n");
        if (glPauseTransformFeedback != nullptr) {
            glPauseTransformFeedback();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glPauseTransformFeedback returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glPauseTransformFeedback\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glPauseTransformFeedback\n");
        return false;
    }
}

bool callGlResumeTransformFeedback(Stack* stack, bool pushReturn) {
    if (stack->isValid()) {
        GAPID_INFO("glResumeTransformFeedback()\n");
        if (glResumeTransformFeedback != nullptr) {
            glResumeTransformFeedback();
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glResumeTransformFeedback returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glResumeTransformFeedback\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glResumeTransformFeedback\n");
        return false;
    }
}

bool callGlTransformFeedbackVaryings(Stack* stack, bool pushReturn) {
    GLenum bufferMode = stack->pop<GLenum>();
    char** varyings = stack->pop<char**>();
    int32_t count = stack->pop<int32_t>();
    uint32_t program = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glTransformFeedbackVaryings(%" PRIu32 ", %" PRId32 ", %p, %u)\n", program,
                   count, varyings, bufferMode);
        if (glTransformFeedbackVaryings != nullptr) {
            glTransformFeedbackVaryings(program, count, varyings, bufferMode);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glTransformFeedbackVaryings returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glTransformFeedbackVaryings\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glTransformFeedbackVaryings\n");
        return false;
    }
}

bool callGlBindVertexArray(Stack* stack, bool pushReturn) {
    uint32_t array = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindVertexArray(%" PRIu32 ")\n", array);
        if (glBindVertexArray != nullptr) {
            glBindVertexArray(array);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindVertexArray returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindVertexArray\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindVertexArray\n");
        return false;
    }
}

bool callGlBindVertexBuffer(Stack* stack, bool pushReturn) {
    int32_t stride = stack->pop<int32_t>();
    int32_t offset = stack->pop<int32_t>();
    uint32_t buffer = stack->pop<uint32_t>();
    uint32_t bindingindex = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glBindVertexBuffer(%" PRIu32 ", %" PRIu32 ", %" PRId32 ", %" PRId32 ")\n",
                   bindingindex, buffer, offset, stride);
        if (glBindVertexBuffer != nullptr) {
            glBindVertexBuffer(bindingindex, buffer, offset, stride);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glBindVertexBuffer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glBindVertexBuffer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glBindVertexBuffer\n");
        return false;
    }
}

bool callGlDeleteVertexArrays(Stack* stack, bool pushReturn) {
    uint32_t* arrays = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDeleteVertexArrays(%" PRId32 ", %p)\n", count, arrays);
        if (glDeleteVertexArrays != nullptr) {
            glDeleteVertexArrays(count, arrays);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDeleteVertexArrays returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDeleteVertexArrays\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDeleteVertexArrays\n");
        return false;
    }
}

bool callGlDisableVertexAttribArray(Stack* stack, bool pushReturn) {
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glDisableVertexAttribArray(%" PRIu32 ")\n", location);
        if (glDisableVertexAttribArray != nullptr) {
            glDisableVertexAttribArray(location);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glDisableVertexAttribArray returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glDisableVertexAttribArray\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glDisableVertexAttribArray\n");
        return false;
    }
}

bool callGlEnableVertexAttribArray(Stack* stack, bool pushReturn) {
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glEnableVertexAttribArray(%" PRIu32 ")\n", location);
        if (glEnableVertexAttribArray != nullptr) {
            glEnableVertexAttribArray(location);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glEnableVertexAttribArray returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glEnableVertexAttribArray\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glEnableVertexAttribArray\n");
        return false;
    }
}

bool callGlGenVertexArrays(Stack* stack, bool pushReturn) {
    uint32_t* arrays = stack->pop<uint32_t*>();
    int32_t count = stack->pop<int32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGenVertexArrays(%" PRId32 ", %p)\n", count, arrays);
        if (glGenVertexArrays != nullptr) {
            glGenVertexArrays(count, arrays);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGenVertexArrays returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGenVertexArrays\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGenVertexArrays\n");
        return false;
    }
}

bool callGlGetVertexAttribIiv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetVertexAttribIiv(%" PRIu32 ", %u, %p)\n", index, pname, params);
        if (glGetVertexAttribIiv != nullptr) {
            glGetVertexAttribIiv(index, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetVertexAttribIiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribIiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetVertexAttribIiv\n");
        return false;
    }
}

bool callGlGetVertexAttribIuiv(Stack* stack, bool pushReturn) {
    uint32_t* params = stack->pop<uint32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetVertexAttribIuiv(%" PRIu32 ", %u, %p)\n", index, pname, params);
        if (glGetVertexAttribIuiv != nullptr) {
            glGetVertexAttribIuiv(index, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetVertexAttribIuiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribIuiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetVertexAttribIuiv\n");
        return false;
    }
}

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

bool callGlGetVertexAttribfv(Stack* stack, bool pushReturn) {
    float* params = stack->pop<float*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetVertexAttribfv(%" PRIu32 ", %u, %p)\n", index, pname, params);
        if (glGetVertexAttribfv != nullptr) {
            glGetVertexAttribfv(index, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetVertexAttribfv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribfv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetVertexAttribfv\n");
        return false;
    }
}

bool callGlGetVertexAttribiv(Stack* stack, bool pushReturn) {
    int32_t* params = stack->pop<int32_t*>();
    GLenum pname = stack->pop<GLenum>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glGetVertexAttribiv(%" PRIu32 ", %u, %p)\n", index, pname, params);
        if (glGetVertexAttribiv != nullptr) {
            glGetVertexAttribiv(index, pname, params);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glGetVertexAttribiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glGetVertexAttribiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glGetVertexAttribiv\n");
        return false;
    }
}

bool callGlIsVertexArray(Stack* stack, bool pushReturn) {
    uint32_t array = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glIsVertexArray(%" PRIu32 ")\n", array);
        if (glIsVertexArray != nullptr) {
            bool return_value = glIsVertexArray(array);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<bool>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glIsVertexArray returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glIsVertexArray\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glIsVertexArray\n");
        return false;
    }
}

bool callGlVertexAttrib1f(Stack* stack, bool pushReturn) {
    float value0 = stack->pop<float>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib1f(%" PRIu32 ", %f)\n", location, value0);
        if (glVertexAttrib1f != nullptr) {
            glVertexAttrib1f(location, value0);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib1f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib1f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib1f\n");
        return false;
    }
}

bool callGlVertexAttrib1fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib1fv(%" PRIu32 ", %p)\n", location, value);
        if (glVertexAttrib1fv != nullptr) {
            glVertexAttrib1fv(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib1fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib1fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib1fv\n");
        return false;
    }
}

bool callGlVertexAttrib2f(Stack* stack, bool pushReturn) {
    float value1 = stack->pop<float>();
    float value0 = stack->pop<float>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib2f(%" PRIu32 ", %f, %f)\n", location, value0, value1);
        if (glVertexAttrib2f != nullptr) {
            glVertexAttrib2f(location, value0, value1);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib2f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib2f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib2f\n");
        return false;
    }
}

bool callGlVertexAttrib2fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib2fv(%" PRIu32 ", %p)\n", location, value);
        if (glVertexAttrib2fv != nullptr) {
            glVertexAttrib2fv(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib2fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib2fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib2fv\n");
        return false;
    }
}

bool callGlVertexAttrib3f(Stack* stack, bool pushReturn) {
    float value2 = stack->pop<float>();
    float value1 = stack->pop<float>();
    float value0 = stack->pop<float>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib3f(%" PRIu32 ", %f, %f, %f)\n", location, value0, value1, value2);
        if (glVertexAttrib3f != nullptr) {
            glVertexAttrib3f(location, value0, value1, value2);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib3f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib3f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib3f\n");
        return false;
    }
}

bool callGlVertexAttrib3fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib3fv(%" PRIu32 ", %p)\n", location, value);
        if (glVertexAttrib3fv != nullptr) {
            glVertexAttrib3fv(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib3fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib3fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib3fv\n");
        return false;
    }
}

bool callGlVertexAttrib4f(Stack* stack, bool pushReturn) {
    float value3 = stack->pop<float>();
    float value2 = stack->pop<float>();
    float value1 = stack->pop<float>();
    float value0 = stack->pop<float>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib4f(%" PRIu32 ", %f, %f, %f, %f)\n", location, value0, value1,
                   value2, value3);
        if (glVertexAttrib4f != nullptr) {
            glVertexAttrib4f(location, value0, value1, value2, value3);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib4f returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib4f\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib4f\n");
        return false;
    }
}

bool callGlVertexAttrib4fv(Stack* stack, bool pushReturn) {
    float* value = stack->pop<float*>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttrib4fv(%" PRIu32 ", %p)\n", location, value);
        if (glVertexAttrib4fv != nullptr) {
            glVertexAttrib4fv(location, value);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttrib4fv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttrib4fv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttrib4fv\n");
        return false;
    }
}

bool callGlVertexAttribBinding(Stack* stack, bool pushReturn) {
    uint32_t bindingindex = stack->pop<uint32_t>();
    uint32_t attribindex = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribBinding(%" PRIu32 ", %" PRIu32 ")\n", attribindex, bindingindex);
        if (glVertexAttribBinding != nullptr) {
            glVertexAttribBinding(attribindex, bindingindex);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribBinding returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribBinding\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribBinding\n");
        return false;
    }
}

bool callGlVertexAttribDivisor(Stack* stack, bool pushReturn) {
    uint32_t divisor = stack->pop<uint32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribDivisor(%" PRIu32 ", %" PRIu32 ")\n", index, divisor);
        if (glVertexAttribDivisor != nullptr) {
            glVertexAttribDivisor(index, divisor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribDivisor returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribDivisor\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribDivisor\n");
        return false;
    }
}

bool callGlVertexAttribFormat(Stack* stack, bool pushReturn) {
    uint32_t relativeoffset = stack->pop<uint32_t>();
    uint8_t normalized = stack->pop<uint8_t>();
    GLenum type = stack->pop<GLenum>();
    int32_t size = stack->pop<int32_t>();
    uint32_t attribindex = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribFormat(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRIu32 ")\n",
                   attribindex, size, type, normalized, relativeoffset);
        if (glVertexAttribFormat != nullptr) {
            glVertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribFormat returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribFormat\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribFormat\n");
        return false;
    }
}

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

bool callGlVertexAttribI4iv(Stack* stack, bool pushReturn) {
    int32_t* v = stack->pop<int32_t*>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribI4iv(%" PRIu32 ", %p)\n", index, v);
        if (glVertexAttribI4iv != nullptr) {
            glVertexAttribI4iv(index, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribI4iv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4iv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribI4iv\n");
        return false;
    }
}

bool callGlVertexAttribI4ui(Stack* stack, bool pushReturn) {
    uint32_t w = stack->pop<uint32_t>();
    uint32_t z = stack->pop<uint32_t>();
    uint32_t y = stack->pop<uint32_t>();
    uint32_t x = stack->pop<uint32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribI4ui(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32 ", %" PRIu32
                   ")\n",
                   index, x, y, z, w);
        if (glVertexAttribI4ui != nullptr) {
            glVertexAttribI4ui(index, x, y, z, w);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribI4ui returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4ui\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribI4ui\n");
        return false;
    }
}

bool callGlVertexAttribI4uiv(Stack* stack, bool pushReturn) {
    uint32_t* v = stack->pop<uint32_t*>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribI4uiv(%" PRIu32 ", %p)\n", index, v);
        if (glVertexAttribI4uiv != nullptr) {
            glVertexAttribI4uiv(index, v);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribI4uiv returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribI4uiv\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribI4uiv\n");
        return false;
    }
}

bool callGlVertexAttribIFormat(Stack* stack, bool pushReturn) {
    uint32_t relativeoffset = stack->pop<uint32_t>();
    GLenum type = stack->pop<GLenum>();
    int32_t size = stack->pop<int32_t>();
    uint32_t attribindex = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribIFormat(%" PRIu32 ", %" PRId32 ", %u, %" PRIu32 ")\n",
                   attribindex, size, type, relativeoffset);
        if (glVertexAttribIFormat != nullptr) {
            glVertexAttribIFormat(attribindex, size, type, relativeoffset);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribIFormat returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribIFormat\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribIFormat\n");
        return false;
    }
}

bool callGlVertexAttribIPointer(Stack* stack, bool pushReturn) {
    void* pointer = stack->pop<void*>();
    int32_t stride = stack->pop<int32_t>();
    GLenum type = stack->pop<GLenum>();
    int32_t size = stack->pop<int32_t>();
    uint32_t index = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribIPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRId32 ", %p)\n", index,
                   size, type, stride, pointer);
        if (glVertexAttribIPointer != nullptr) {
            glVertexAttribIPointer(index, size, type, stride, pointer);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribIPointer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribIPointer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribIPointer\n");
        return false;
    }
}

bool callGlVertexAttribPointer(Stack* stack, bool pushReturn) {
    void* data = stack->pop<void*>();
    int32_t stride = stack->pop<int32_t>();
    bool normalized = stack->pop<bool>();
    GLenum type = stack->pop<GLenum>();
    int32_t size = stack->pop<int32_t>();
    uint32_t location = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %d, %" PRId32 ", %p)\n",
                   location, size, type, normalized, stride, data);
        if (glVertexAttribPointer != nullptr) {
            glVertexAttribPointer(location, size, type, normalized, stride, data);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexAttribPointer returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexAttribPointer\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexAttribPointer\n");
        return false;
    }
}

bool callGlVertexBindingDivisor(Stack* stack, bool pushReturn) {
    uint32_t divisor = stack->pop<uint32_t>();
    uint32_t bindingindex = stack->pop<uint32_t>();
    if (stack->isValid()) {
        GAPID_INFO("glVertexBindingDivisor(%" PRIu32 ", %" PRIu32 ")\n", bindingindex, divisor);
        if (glVertexBindingDivisor != nullptr) {
            glVertexBindingDivisor(bindingindex, divisor);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glVertexBindingDivisor returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glVertexBindingDivisor\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glVertexBindingDivisor\n");
        return false;
    }
}

bool callEglInitialize(Stack* stack, bool pushReturn) {
    int* minor = stack->pop<int*>();
    int* major = stack->pop<int*>();
    void* dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglInitialize(%p, %p, %p)\n", dpy, major, minor);
        if (eglInitialize != nullptr) {
            int return_value = eglInitialize(dpy, major, minor);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("eglInitialize returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglInitialize\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglInitialize\n");
        return false;
    }
}

bool callEglCreateContext(Stack* stack, bool pushReturn) {
    int* attrib_list = stack->pop<int*>();
    void* share_context = stack->pop<void*>();
    void* config = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglCreateContext(%p, %p, %p, %p)\n", display, config, share_context,
                   attrib_list);
        if (eglCreateContext != nullptr) {
            void* return_value = eglCreateContext(display, config, share_context, attrib_list);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<void*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("eglCreateContext returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglCreateContext\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglCreateContext\n");
        return false;
    }
}

bool callEglMakeCurrent(Stack* stack, bool pushReturn) {
    void* context = stack->pop<void*>();
    void* read = stack->pop<void*>();
    void* draw = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglMakeCurrent(%p, %p, %p, %p)\n", display, draw, read, context);
        if (eglMakeCurrent != nullptr) {
            int return_value = eglMakeCurrent(display, draw, read, context);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("eglMakeCurrent returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglMakeCurrent\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglMakeCurrent\n");
        return false;
    }
}

bool callEglSwapBuffers(Stack* stack, bool pushReturn) {
    void* surface = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglSwapBuffers(%p, %p)\n", display, surface);
        if (eglSwapBuffers != nullptr) {
            int return_value = eglSwapBuffers(display, surface);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("eglSwapBuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglSwapBuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglSwapBuffers\n");
        return false;
    }
}

bool callEglQuerySurface(Stack* stack, bool pushReturn) {
    int* value = stack->pop<int*>();
    int attribute = stack->pop<int>();
    void* surface = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("eglQuerySurface(%p, %p, %d, %p)\n", display, surface, attribute, value);
        if (eglQuerySurface != nullptr) {
            int return_value = eglQuerySurface(display, surface, attribute, value);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("eglQuerySurface returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function eglQuerySurface\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function eglQuerySurface\n");
        return false;
    }
}

bool callGlXCreateContext(Stack* stack, bool pushReturn) {
    bool direct = stack->pop<bool>();
    void* shareList = stack->pop<void*>();
    void* vis = stack->pop<void*>();
    void* dpy = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glXCreateContext(%p, %p, %p, %d)\n", dpy, vis, shareList, direct);
        if (glXCreateContext != nullptr) {
            void* return_value = glXCreateContext(dpy, vis, shareList, direct);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<void*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glXCreateContext returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glXCreateContext\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glXCreateContext\n");
        return false;
    }
}

bool callGlXCreateNewContext(Stack* stack, bool pushReturn) {
    bool direct = stack->pop<bool>();
    void* shared = stack->pop<void*>();
    uint32_t type = stack->pop<uint32_t>();
    void* fbconfig = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glXCreateNewContext(%p, %p, %" PRIu32 ", %p, %d)\n", display, fbconfig, type,
                   shared, direct);
        if (glXCreateNewContext != nullptr) {
            void* return_value = glXCreateNewContext(display, fbconfig, type, shared, direct);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<void*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glXCreateNewContext returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glXCreateNewContext\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glXCreateNewContext\n");
        return false;
    }
}

bool callGlXMakeContextCurrent(Stack* stack, bool pushReturn) {
    void* ctx = stack->pop<void*>();
    void* read = stack->pop<void*>();
    void* draw = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glXMakeContextCurrent(%p, %p, %p, %p)\n", display, draw, read, ctx);
        if (glXMakeContextCurrent != nullptr) {
            int return_value = glXMakeContextCurrent(display, draw, read, ctx);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glXMakeContextCurrent returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glXMakeContextCurrent\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glXMakeContextCurrent\n");
        return false;
    }
}

bool callGlXMakeCurrent(Stack* stack, bool pushReturn) {
    void* ctx = stack->pop<void*>();
    void* drawable = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glXMakeCurrent(%p, %p, %p)\n", display, drawable, ctx);
        if (glXMakeCurrent != nullptr) {
            int return_value = glXMakeCurrent(display, drawable, ctx);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glXMakeCurrent returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glXMakeCurrent\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glXMakeCurrent\n");
        return false;
    }
}

bool callGlXSwapBuffers(Stack* stack, bool pushReturn) {
    void* drawable = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glXSwapBuffers(%p, %p)\n", display, drawable);
        if (glXSwapBuffers != nullptr) {
            glXSwapBuffers(display, drawable);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glXSwapBuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glXSwapBuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glXSwapBuffers\n");
        return false;
    }
}

bool callGlXQueryDrawable(Stack* stack, bool pushReturn) {
    int* value = stack->pop<int*>();
    int attribute = stack->pop<int>();
    void* draw = stack->pop<void*>();
    void* display = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("glXQueryDrawable(%p, %p, %d, %p)\n", display, draw, attribute, value);
        if (glXQueryDrawable != nullptr) {
            int return_value = glXQueryDrawable(display, draw, attribute, value);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("glXQueryDrawable returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function glXQueryDrawable\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function glXQueryDrawable\n");
        return false;
    }
}

bool callWglCreateContext(Stack* stack, bool pushReturn) {
    void* hdc = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("wglCreateContext(%p)\n", hdc);
        if (wglCreateContext != nullptr) {
            void* return_value = wglCreateContext(hdc);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<void*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("wglCreateContext returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function wglCreateContext\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function wglCreateContext\n");
        return false;
    }
}

bool callWglCreateContextAttribsARB(Stack* stack, bool pushReturn) {
    int* attribList = stack->pop<int*>();
    void* hShareContext = stack->pop<void*>();
    void* hdc = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("wglCreateContextAttribsARB(%p, %p, %p)\n", hdc, hShareContext, attribList);
        if (wglCreateContextAttribsARB != nullptr) {
            void* return_value = wglCreateContextAttribsARB(hdc, hShareContext, attribList);
            GAPID_INFO("Returned: %p\n", return_value);
            if (pushReturn) {
                stack->push<void*>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("wglCreateContextAttribsARB returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function wglCreateContextAttribsARB\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function wglCreateContextAttribsARB\n");
        return false;
    }
}

bool callWglMakeCurrent(Stack* stack, bool pushReturn) {
    void* hglrc = stack->pop<void*>();
    void* hdc = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("wglMakeCurrent(%p, %p)\n", hdc, hglrc);
        if (wglMakeCurrent != nullptr) {
            int return_value = wglMakeCurrent(hdc, hglrc);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("wglMakeCurrent returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function wglMakeCurrent\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function wglMakeCurrent\n");
        return false;
    }
}

bool callWglSwapBuffers(Stack* stack, bool pushReturn) {
    void* hdc = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("wglSwapBuffers(%p)\n", hdc);
        if (wglSwapBuffers != nullptr) {
            wglSwapBuffers(hdc);
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("wglSwapBuffers returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function wglSwapBuffers\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function wglSwapBuffers\n");
        return false;
    }
}

bool callCGLCreateContext(Stack* stack, bool pushReturn) {
    void** ctx = stack->pop<void**>();
    void* share = stack->pop<void*>();
    void* pix = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("CGLCreateContext(%p, %p, %p)\n", pix, share, ctx);
        if (CGLCreateContext != nullptr) {
            int return_value = CGLCreateContext(pix, share, ctx);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("CGLCreateContext returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function CGLCreateContext\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function CGLCreateContext\n");
        return false;
    }
}

bool callCGLSetCurrentContext(Stack* stack, bool pushReturn) {
    void* ctx = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("CGLSetCurrentContext(%p)\n", ctx);
        if (CGLSetCurrentContext != nullptr) {
            int return_value = CGLSetCurrentContext(ctx);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("CGLSetCurrentContext returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function CGLSetCurrentContext\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function CGLSetCurrentContext\n");
        return false;
    }
}

bool callCGLGetSurface(Stack* stack, bool pushReturn) {
    int32_t* sid = stack->pop<int32_t*>();
    int32_t* wid = stack->pop<int32_t*>();
    void** cid = stack->pop<void**>();
    void* ctx = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("CGLGetSurface(%p, %p, %p, %p)\n", ctx, cid, wid, sid);
        if (CGLGetSurface != nullptr) {
            int return_value = CGLGetSurface(ctx, cid, wid, sid);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("CGLGetSurface returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function CGLGetSurface\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function CGLGetSurface\n");
        return false;
    }
}

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

bool callCGLFlushDrawable(Stack* stack, bool pushReturn) {
    void* ctx = stack->pop<void*>();
    if (stack->isValid()) {
        GAPID_INFO("CGLFlushDrawable(%p)\n", ctx);
        if (CGLFlushDrawable != nullptr) {
            int return_value = CGLFlushDrawable(ctx);
            GAPID_INFO("Returned: %d\n", return_value);
            if (pushReturn) {
                stack->push<int>(return_value);
            }
            const GLenum err = glGetError();
            if (err != GLenum::GL_NO_ERROR) {
                GAPID_WARNING("CGLFlushDrawable returned error: 0x%x\n", err);
            }
        } else {
            GAPID_WARNING("Attempted to call unsupported function CGLFlushDrawable\n");
        }
        return true;
    } else {
        GAPID_WARNING("Error during calling function CGLFlushDrawable\n");
        return false;
    }
}

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

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

}  // end of anonymous namespace

PFNGLBLENDBARRIERKHR glBlendBarrierKHR = nullptr;
PFNGLBLENDEQUATIONSEPARATEIEXT glBlendEquationSeparateiEXT = nullptr;
PFNGLBLENDEQUATIONIEXT glBlendEquationiEXT = nullptr;
PFNGLBLENDFUNCSEPARATEIEXT glBlendFuncSeparateiEXT = nullptr;
PFNGLBLENDFUNCIEXT glBlendFunciEXT = nullptr;
PFNGLCOLORMASKIEXT glColorMaskiEXT = nullptr;
PFNGLCOPYIMAGESUBDATAEXT glCopyImageSubDataEXT = nullptr;
PFNGLDEBUGMESSAGECALLBACKKHR glDebugMessageCallbackKHR = nullptr;
PFNGLDEBUGMESSAGECONTROLKHR glDebugMessageControlKHR = nullptr;
PFNGLDEBUGMESSAGEINSERTKHR glDebugMessageInsertKHR = nullptr;
PFNGLDISABLEIEXT glDisableiEXT = nullptr;
PFNGLENABLEIEXT glEnableiEXT = nullptr;
PFNGLFRAMEBUFFERTEXTUREEXT glFramebufferTextureEXT = nullptr;
PFNGLGETDEBUGMESSAGELOGKHR glGetDebugMessageLogKHR = nullptr;
PFNGLGETOBJECTLABELKHR glGetObjectLabelKHR = nullptr;
PFNGLGETOBJECTPTRLABELKHR glGetObjectPtrLabelKHR = nullptr;
PFNGLGETPOINTERVKHR glGetPointervKHR = nullptr;
PFNGLGETSAMPLERPARAMETERIIVEXT glGetSamplerParameterIivEXT = nullptr;
PFNGLGETSAMPLERPARAMETERIUIVEXT glGetSamplerParameterIuivEXT = nullptr;
PFNGLGETTEXPARAMETERIIVEXT glGetTexParameterIivEXT = nullptr;
PFNGLGETTEXPARAMETERIUIVEXT glGetTexParameterIuivEXT = nullptr;
PFNGLISENABLEDIEXT glIsEnablediEXT = nullptr;
PFNGLMINSAMPLESHADINGOES glMinSampleShadingOES = nullptr;
PFNGLOBJECTLABELKHR glObjectLabelKHR = nullptr;
PFNGLOBJECTPTRLABELKHR glObjectPtrLabelKHR = nullptr;
PFNGLPATCHPARAMETERIEXT glPatchParameteriEXT = nullptr;
PFNGLPOPDEBUGGROUPKHR glPopDebugGroupKHR = nullptr;
PFNGLPRIMITIVEBOUNDINGBOXEXT glPrimitiveBoundingBoxEXT = nullptr;
PFNGLPUSHDEBUGGROUPKHR glPushDebugGroupKHR = nullptr;
PFNGLSAMPLERPARAMETERIIVEXT glSamplerParameterIivEXT = nullptr;
PFNGLSAMPLERPARAMETERIUIVEXT glSamplerParameterIuivEXT = nullptr;
PFNGLTEXBUFFEREXT glTexBufferEXT = nullptr;
PFNGLTEXBUFFERRANGEEXT glTexBufferRangeEXT = nullptr;
PFNGLTEXPARAMETERIIVEXT glTexParameterIivEXT = nullptr;
PFNGLTEXPARAMETERIUIVEXT glTexParameterIuivEXT = nullptr;
PFNGLTEXSTORAGE3DMULTISAMPLEOES glTexStorage3DMultisampleOES = nullptr;
PFNGLBEGINQUERY glBeginQuery = nullptr;
PFNGLDELETEQUERIES glDeleteQueries = nullptr;
PFNGLENDQUERY glEndQuery = nullptr;
PFNGLGENQUERIES glGenQueries = nullptr;
PFNGLGETQUERYOBJECTUIV glGetQueryObjectuiv = nullptr;
PFNGLGETQUERYIV glGetQueryiv = nullptr;
PFNGLISQUERY glIsQuery = nullptr;
PFNGLBINDBUFFER glBindBuffer = nullptr;
PFNGLBINDBUFFERBASE glBindBufferBase = nullptr;
PFNGLBINDBUFFERRANGE glBindBufferRange = nullptr;
PFNGLBUFFERDATA glBufferData = nullptr;
PFNGLBUFFERSUBDATA glBufferSubData = nullptr;
PFNGLCOPYBUFFERSUBDATA glCopyBufferSubData = nullptr;
PFNGLDELETEBUFFERS glDeleteBuffers = nullptr;
PFNGLGENBUFFERS glGenBuffers = nullptr;
PFNGLGETBUFFERPARAMETERI64V glGetBufferParameteri64v = nullptr;
PFNGLGETBUFFERPARAMETERIV glGetBufferParameteriv = nullptr;
PFNGLGETBUFFERPOINTERV glGetBufferPointerv = nullptr;
PFNGLISBUFFER glIsBuffer = nullptr;
PFNGLMAPBUFFERRANGE glMapBufferRange = nullptr;
PFNGLUNMAPBUFFER glUnmapBuffer = nullptr;
PFNGLDRAWARRAYS glDrawArrays = nullptr;
PFNGLDRAWARRAYSINDIRECT glDrawArraysIndirect = nullptr;
PFNGLDRAWARRAYSINSTANCED glDrawArraysInstanced = nullptr;
PFNGLDRAWBUFFERS glDrawBuffers = nullptr;
PFNGLDRAWELEMENTS glDrawElements = nullptr;
PFNGLDRAWELEMENTSINDIRECT glDrawElementsIndirect = nullptr;
PFNGLDRAWELEMENTSINSTANCED glDrawElementsInstanced = nullptr;
PFNGLDRAWRANGEELEMENTS glDrawRangeElements = nullptr;
PFNGLACTIVESHADERPROGRAMEXT glActiveShaderProgramEXT = nullptr;
PFNGLALPHAFUNCQCOM glAlphaFuncQCOM = nullptr;
PFNGLBEGINCONDITIONALRENDERNV glBeginConditionalRenderNV = nullptr;
PFNGLBEGINPERFMONITORAMD glBeginPerfMonitorAMD = nullptr;
PFNGLBEGINPERFQUERYINTEL glBeginPerfQueryINTEL = nullptr;
PFNGLBEGINQUERYEXT glBeginQueryEXT = nullptr;
PFNGLBINDPROGRAMPIPELINEEXT glBindProgramPipelineEXT = nullptr;
PFNGLBINDVERTEXARRAYOES glBindVertexArrayOES = nullptr;
PFNGLBLENDBARRIERNV glBlendBarrierNV = nullptr;
PFNGLBLENDEQUATIONSEPARATEIOES glBlendEquationSeparateiOES = nullptr;
PFNGLBLENDEQUATIONIOES glBlendEquationiOES = nullptr;
PFNGLBLENDFUNCSEPARATEIOES glBlendFuncSeparateiOES = nullptr;
PFNGLBLENDFUNCIOES glBlendFunciOES = nullptr;
PFNGLBLENDPARAMETERINV glBlendParameteriNV = nullptr;
PFNGLBLITFRAMEBUFFERANGLE glBlitFramebufferANGLE = nullptr;
PFNGLBLITFRAMEBUFFERNV glBlitFramebufferNV = nullptr;
PFNGLBUFFERSTORAGEEXT glBufferStorageEXT = nullptr;
PFNGLCLIENTWAITSYNCAPPLE glClientWaitSyncAPPLE = nullptr;
PFNGLCOLORMASKIOES glColorMaskiOES = nullptr;
PFNGLCOMPRESSEDTEXIMAGE3DOES glCompressedTexImage3DOES = nullptr;
PFNGLCOMPRESSEDTEXSUBIMAGE3DOES glCompressedTexSubImage3DOES = nullptr;
PFNGLCOPYBUFFERSUBDATANV glCopyBufferSubDataNV = nullptr;
PFNGLCOPYIMAGESUBDATAOES glCopyImageSubDataOES = nullptr;
PFNGLCOPYPATHNV glCopyPathNV = nullptr;
PFNGLCOPYTEXSUBIMAGE3DOES glCopyTexSubImage3DOES = nullptr;
PFNGLCOPYTEXTURELEVELSAPPLE glCopyTextureLevelsAPPLE = nullptr;
PFNGLCOVERFILLPATHINSTANCEDNV glCoverFillPathInstancedNV = nullptr;
PFNGLCOVERFILLPATHNV glCoverFillPathNV = nullptr;
PFNGLCOVERSTROKEPATHINSTANCEDNV glCoverStrokePathInstancedNV = nullptr;
PFNGLCOVERSTROKEPATHNV glCoverStrokePathNV = nullptr;
PFNGLCOVERAGEMASKNV glCoverageMaskNV = nullptr;
PFNGLCOVERAGEOPERATIONNV glCoverageOperationNV = nullptr;
PFNGLCREATEPERFQUERYINTEL glCreatePerfQueryINTEL = nullptr;
PFNGLCREATESHADERPROGRAMVEXT glCreateShaderProgramvEXT = nullptr;
PFNGLDELETEFENCESNV glDeleteFencesNV = nullptr;
PFNGLDELETEPATHSNV glDeletePathsNV = nullptr;
PFNGLDELETEPERFMONITORSAMD glDeletePerfMonitorsAMD = nullptr;
PFNGLDELETEPERFQUERYINTEL glDeletePerfQueryINTEL = nullptr;
PFNGLDELETEPROGRAMPIPELINESEXT glDeleteProgramPipelinesEXT = nullptr;
PFNGLDELETEQUERIESEXT glDeleteQueriesEXT = nullptr;
PFNGLDELETESYNCAPPLE glDeleteSyncAPPLE = nullptr;
PFNGLDELETEVERTEXARRAYSOES glDeleteVertexArraysOES = nullptr;
PFNGLDEPTHRANGEARRAYFVNV glDepthRangeArrayfvNV = nullptr;
PFNGLDEPTHRANGEINDEXEDFNV glDepthRangeIndexedfNV = nullptr;
PFNGLDISABLEDRIVERCONTROLQCOM glDisableDriverControlQCOM = nullptr;
PFNGLDISABLEINV glDisableiNV = nullptr;
PFNGLDISABLEIOES glDisableiOES = nullptr;
PFNGLDISCARDFRAMEBUFFEREXT glDiscardFramebufferEXT = nullptr;
PFNGLDRAWARRAYSINSTANCEDANGLE glDrawArraysInstancedANGLE = nullptr;
PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXT glDrawArraysInstancedBaseInstanceEXT = nullptr;
PFNGLDRAWARRAYSINSTANCEDEXT glDrawArraysInstancedEXT = nullptr;
PFNGLDRAWARRAYSINSTANCEDNV glDrawArraysInstancedNV = nullptr;
PFNGLDRAWBUFFERSEXT glDrawBuffersEXT = nullptr;
PFNGLDRAWBUFFERSINDEXEDEXT glDrawBuffersIndexedEXT = nullptr;
PFNGLDRAWBUFFERSNV glDrawBuffersNV = nullptr;
PFNGLDRAWELEMENTSBASEVERTEXEXT glDrawElementsBaseVertexEXT = nullptr;
PFNGLDRAWELEMENTSBASEVERTEXOES glDrawElementsBaseVertexOES = nullptr;
PFNGLDRAWELEMENTSINSTANCEDANGLE glDrawElementsInstancedANGLE = nullptr;
PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXT glDrawElementsInstancedBaseInstanceEXT = nullptr;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXT glDrawElementsInstancedBaseVertexEXT = nullptr;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXOES glDrawElementsInstancedBaseVertexOES = nullptr;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXT
        glDrawElementsInstancedBaseVertexBaseInstanceEXT = nullptr;
PFNGLDRAWELEMENTSINSTANCEDEXT glDrawElementsInstancedEXT = nullptr;
PFNGLDRAWELEMENTSINSTANCEDNV glDrawElementsInstancedNV = nullptr;
PFNGLDRAWRANGEELEMENTSBASEVERTEXEXT glDrawRangeElementsBaseVertexEXT = nullptr;
PFNGLDRAWRANGEELEMENTSBASEVERTEXOES glDrawRangeElementsBaseVertexOES = nullptr;
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOES glEGLImageTargetRenderbufferStorageOES = nullptr;
PFNGLEGLIMAGETARGETTEXTURE2DOES glEGLImageTargetTexture2DOES = nullptr;
PFNGLENABLEDRIVERCONTROLQCOM glEnableDriverControlQCOM = nullptr;
PFNGLENABLEINV glEnableiNV = nullptr;
PFNGLENABLEIOES glEnableiOES = nullptr;
PFNGLENDCONDITIONALRENDERNV glEndConditionalRenderNV = nullptr;
PFNGLENDPERFMONITORAMD glEndPerfMonitorAMD = nullptr;
PFNGLENDPERFQUERYINTEL glEndPerfQueryINTEL = nullptr;
PFNGLENDQUERYEXT glEndQueryEXT = nullptr;
PFNGLENDTILINGQCOM glEndTilingQCOM = nullptr;
PFNGLEXTGETBUFFERPOINTERVQCOM glExtGetBufferPointervQCOM = nullptr;
PFNGLEXTGETBUFFERSQCOM glExtGetBuffersQCOM = nullptr;
PFNGLEXTGETFRAMEBUFFERSQCOM glExtGetFramebuffersQCOM = nullptr;
PFNGLEXTGETPROGRAMBINARYSOURCEQCOM glExtGetProgramBinarySourceQCOM = nullptr;
PFNGLEXTGETPROGRAMSQCOM glExtGetProgramsQCOM = nullptr;
PFNGLEXTGETRENDERBUFFERSQCOM glExtGetRenderbuffersQCOM = nullptr;
PFNGLEXTGETSHADERSQCOM glExtGetShadersQCOM = nullptr;
PFNGLEXTGETTEXLEVELPARAMETERIVQCOM glExtGetTexLevelParameterivQCOM = nullptr;
PFNGLEXTGETTEXSUBIMAGEQCOM glExtGetTexSubImageQCOM = nullptr;
PFNGLEXTGETTEXTURESQCOM glExtGetTexturesQCOM = nullptr;
PFNGLEXTISPROGRAMBINARYQCOM glExtIsProgramBinaryQCOM = nullptr;
PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOM glExtTexObjectStateOverrideiQCOM = nullptr;
PFNGLFENCESYNCAPPLE glFenceSyncAPPLE = nullptr;
PFNGLFINISHFENCENV glFinishFenceNV = nullptr;
PFNGLFLUSHMAPPEDBUFFERRANGEEXT glFlushMappedBufferRangeEXT = nullptr;
PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXT glFramebufferTexture2DMultisampleEXT = nullptr;
PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG glFramebufferTexture2DMultisampleIMG = nullptr;
PFNGLFRAMEBUFFERTEXTURE3DOES glFramebufferTexture3DOES = nullptr;
PFNGLFRAMEBUFFERTEXTUREOES glFramebufferTextureOES = nullptr;
PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVR glFramebufferTextureMultiviewOVR = nullptr;
PFNGLGENFENCESNV glGenFencesNV = nullptr;
PFNGLGENPATHSNV glGenPathsNV = nullptr;
PFNGLGENPERFMONITORSAMD glGenPerfMonitorsAMD = nullptr;
PFNGLGENPROGRAMPIPELINESEXT glGenProgramPipelinesEXT = nullptr;
PFNGLGENQUERIESEXT glGenQueriesEXT = nullptr;
PFNGLGENVERTEXARRAYSOES glGenVertexArraysOES = nullptr;
PFNGLGETBUFFERPOINTERVOES glGetBufferPointervOES = nullptr;
PFNGLGETDRIVERCONTROLSTRINGQCOM glGetDriverControlStringQCOM = nullptr;
PFNGLGETDRIVERCONTROLSQCOM glGetDriverControlsQCOM = nullptr;
PFNGLGETFENCEIVNV glGetFenceivNV = nullptr;
PFNGLGETFIRSTPERFQUERYIDINTEL glGetFirstPerfQueryIdINTEL = nullptr;
PFNGLGETFLOATI_VNV glGetFloati_vNV = nullptr;
PFNGLGETGRAPHICSRESETSTATUSEXT glGetGraphicsResetStatusEXT = nullptr;
PFNGLGETGRAPHICSRESETSTATUSKHR glGetGraphicsResetStatusKHR = nullptr;
PFNGLGETIMAGEHANDLENV glGetImageHandleNV = nullptr;
PFNGLGETINTEGER64VAPPLE glGetInteger64vAPPLE = nullptr;
PFNGLGETINTEGERI_VEXT glGetIntegeri_vEXT = nullptr;
PFNGLGETINTERNALFORMATSAMPLEIVNV glGetInternalformatSampleivNV = nullptr;
PFNGLGETNEXTPERFQUERYIDINTEL glGetNextPerfQueryIdINTEL = nullptr;
PFNGLGETOBJECTLABELEXT glGetObjectLabelEXT = nullptr;
PFNGLGETPATHCOMMANDSNV glGetPathCommandsNV = nullptr;
PFNGLGETPATHCOORDSNV glGetPathCoordsNV = nullptr;
PFNGLGETPATHDASHARRAYNV glGetPathDashArrayNV = nullptr;
PFNGLGETPATHLENGTHNV glGetPathLengthNV = nullptr;
PFNGLGETPATHMETRICRANGENV glGetPathMetricRangeNV = nullptr;
PFNGLGETPATHMETRICSNV glGetPathMetricsNV = nullptr;
PFNGLGETPATHPARAMETERFVNV glGetPathParameterfvNV = nullptr;
PFNGLGETPATHPARAMETERIVNV glGetPathParameterivNV = nullptr;
PFNGLGETPATHSPACINGNV glGetPathSpacingNV = nullptr;
PFNGLGETPERFCOUNTERINFOINTEL glGetPerfCounterInfoINTEL = nullptr;
PFNGLGETPERFMONITORCOUNTERDATAAMD glGetPerfMonitorCounterDataAMD = nullptr;
PFNGLGETPERFMONITORCOUNTERINFOAMD glGetPerfMonitorCounterInfoAMD = nullptr;
PFNGLGETPERFMONITORCOUNTERSTRINGAMD glGetPerfMonitorCounterStringAMD = nullptr;
PFNGLGETPERFMONITORCOUNTERSAMD glGetPerfMonitorCountersAMD = nullptr;
PFNGLGETPERFMONITORGROUPSTRINGAMD glGetPerfMonitorGroupStringAMD = nullptr;
PFNGLGETPERFMONITORGROUPSAMD glGetPerfMonitorGroupsAMD = nullptr;
PFNGLGETPERFQUERYDATAINTEL glGetPerfQueryDataINTEL = nullptr;
PFNGLGETPERFQUERYIDBYNAMEINTEL glGetPerfQueryIdByNameINTEL = nullptr;
PFNGLGETPERFQUERYINFOINTEL glGetPerfQueryInfoINTEL = nullptr;
PFNGLGETPROGRAMBINARYOES glGetProgramBinaryOES = nullptr;
PFNGLGETPROGRAMPIPELINEINFOLOGEXT glGetProgramPipelineInfoLogEXT = nullptr;
PFNGLGETPROGRAMPIPELINEIVEXT glGetProgramPipelineivEXT = nullptr;
PFNGLGETPROGRAMRESOURCEFVNV glGetProgramResourcefvNV = nullptr;
PFNGLGETQUERYOBJECTI64VEXT glGetQueryObjecti64vEXT = nullptr;
PFNGLGETQUERYOBJECTIVEXT glGetQueryObjectivEXT = nullptr;
PFNGLGETQUERYOBJECTUI64VEXT glGetQueryObjectui64vEXT = nullptr;
PFNGLGETQUERYOBJECTUIVEXT glGetQueryObjectuivEXT = nullptr;
PFNGLGETQUERYIVEXT glGetQueryivEXT = nullptr;
PFNGLGETSAMPLERPARAMETERIIVOES glGetSamplerParameterIivOES = nullptr;
PFNGLGETSAMPLERPARAMETERIUIVOES glGetSamplerParameterIuivOES = nullptr;
PFNGLGETSYNCIVAPPLE glGetSyncivAPPLE = nullptr;
PFNGLGETTEXPARAMETERIIVOES glGetTexParameterIivOES = nullptr;
PFNGLGETTEXPARAMETERIUIVOES glGetTexParameterIuivOES = nullptr;
PFNGLGETTEXTUREHANDLENV glGetTextureHandleNV = nullptr;
PFNGLGETTEXTURESAMPLERHANDLENV glGetTextureSamplerHandleNV = nullptr;
PFNGLGETTRANSLATEDSHADERSOURCEANGLE glGetTranslatedShaderSourceANGLE = nullptr;
PFNGLGETNUNIFORMFVEXT glGetnUniformfvEXT = nullptr;
PFNGLGETNUNIFORMFVKHR glGetnUniformfvKHR = nullptr;
PFNGLGETNUNIFORMIVEXT glGetnUniformivEXT = nullptr;
PFNGLGETNUNIFORMIVKHR glGetnUniformivKHR = nullptr;
PFNGLGETNUNIFORMUIVKHR glGetnUniformuivKHR = nullptr;
PFNGLINSERTEVENTMARKEREXT glInsertEventMarkerEXT = nullptr;
PFNGLINTERPOLATEPATHSNV glInterpolatePathsNV = nullptr;
PFNGLISENABLEDIOES glIsEnablediOES = nullptr;
PFNGLISENABLEDINV glIsEnablediNV = nullptr;
PFNGLISFENCENV glIsFenceNV = nullptr;
PFNGLISIMAGEHANDLERESIDENTNV glIsImageHandleResidentNV = nullptr;
PFNGLISPATHNV glIsPathNV = nullptr;
PFNGLISPOINTINFILLPATHNV glIsPointInFillPathNV = nullptr;
PFNGLISPOINTINSTROKEPATHNV glIsPointInStrokePathNV = nullptr;
PFNGLISPROGRAMPIPELINEEXT glIsProgramPipelineEXT = nullptr;
PFNGLISQUERYEXT glIsQueryEXT = nullptr;
PFNGLISSYNCAPPLE glIsSyncAPPLE = nullptr;
PFNGLISTEXTUREHANDLERESIDENTNV glIsTextureHandleResidentNV = nullptr;
PFNGLISVERTEXARRAYOES glIsVertexArrayOES = nullptr;
PFNGLLABELOBJECTEXT glLabelObjectEXT = nullptr;
PFNGLMAKEIMAGEHANDLENONRESIDENTNV glMakeImageHandleNonResidentNV = nullptr;
PFNGLMAKEIMAGEHANDLERESIDENTNV glMakeImageHandleResidentNV = nullptr;
PFNGLMAKETEXTUREHANDLENONRESIDENTNV glMakeTextureHandleNonResidentNV = nullptr;
PFNGLMAKETEXTUREHANDLERESIDENTNV glMakeTextureHandleResidentNV = nullptr;
PFNGLMAPBUFFEROES glMapBufferOES = nullptr;
PFNGLMAPBUFFERRANGEEXT glMapBufferRangeEXT = nullptr;
PFNGLMATRIXLOAD3X2FNV glMatrixLoad3x2fNV = nullptr;
PFNGLMATRIXLOAD3X3FNV glMatrixLoad3x3fNV = nullptr;
PFNGLMATRIXLOADTRANSPOSE3X3FNV glMatrixLoadTranspose3x3fNV = nullptr;
PFNGLMATRIXMULT3X2FNV glMatrixMult3x2fNV = nullptr;
PFNGLMATRIXMULT3X3FNV glMatrixMult3x3fNV = nullptr;
PFNGLMATRIXMULTTRANSPOSE3X3FNV glMatrixMultTranspose3x3fNV = nullptr;
PFNGLMULTIDRAWARRAYSEXT glMultiDrawArraysEXT = nullptr;
PFNGLMULTIDRAWARRAYSINDIRECTEXT glMultiDrawArraysIndirectEXT = nullptr;
PFNGLMULTIDRAWELEMENTSBASEVERTEXEXT glMultiDrawElementsBaseVertexEXT = nullptr;
PFNGLMULTIDRAWELEMENTSBASEVERTEXOES glMultiDrawElementsBaseVertexOES = nullptr;
PFNGLMULTIDRAWELEMENTSEXT glMultiDrawElementsEXT = nullptr;
PFNGLMULTIDRAWELEMENTSINDIRECTEXT glMultiDrawElementsIndirectEXT = nullptr;
PFNGLPATCHPARAMETERIOES glPatchParameteriOES = nullptr;
PFNGLPATHCOMMANDSNV glPathCommandsNV = nullptr;
PFNGLPATHCOORDSNV glPathCoordsNV = nullptr;
PFNGLPATHCOVERDEPTHFUNCNV glPathCoverDepthFuncNV = nullptr;
PFNGLPATHDASHARRAYNV glPathDashArrayNV = nullptr;
PFNGLPATHGLYPHINDEXARRAYNV glPathGlyphIndexArrayNV = nullptr;
PFNGLPATHGLYPHINDEXRANGENV glPathGlyphIndexRangeNV = nullptr;
PFNGLPATHGLYPHRANGENV glPathGlyphRangeNV = nullptr;
PFNGLPATHGLYPHSNV glPathGlyphsNV = nullptr;
PFNGLPATHMEMORYGLYPHINDEXARRAYNV glPathMemoryGlyphIndexArrayNV = nullptr;
PFNGLPATHPARAMETERFNV glPathParameterfNV = nullptr;
PFNGLPATHPARAMETERFVNV glPathParameterfvNV = nullptr;
PFNGLPATHPARAMETERINV glPathParameteriNV = nullptr;
PFNGLPATHPARAMETERIVNV glPathParameterivNV = nullptr;
PFNGLPATHSTENCILDEPTHOFFSETNV glPathStencilDepthOffsetNV = nullptr;
PFNGLPATHSTENCILFUNCNV glPathStencilFuncNV = nullptr;
PFNGLPATHSTRINGNV glPathStringNV = nullptr;
PFNGLPATHSUBCOMMANDSNV glPathSubCommandsNV = nullptr;
PFNGLPATHSUBCOORDSNV glPathSubCoordsNV = nullptr;
PFNGLPOINTALONGPATHNV glPointAlongPathNV = nullptr;
PFNGLPOLYGONMODENV glPolygonModeNV = nullptr;
PFNGLPOPGROUPMARKEREXT glPopGroupMarkerEXT = nullptr;
PFNGLPRIMITIVEBOUNDINGBOXOES glPrimitiveBoundingBoxOES = nullptr;
PFNGLPROGRAMBINARYOES glProgramBinaryOES = nullptr;
PFNGLPROGRAMPARAMETERIEXT glProgramParameteriEXT = nullptr;
PFNGLPROGRAMPATHFRAGMENTINPUTGENNV glProgramPathFragmentInputGenNV = nullptr;
PFNGLPROGRAMUNIFORM1FEXT glProgramUniform1fEXT = nullptr;
PFNGLPROGRAMUNIFORM1FVEXT glProgramUniform1fvEXT = nullptr;
PFNGLPROGRAMUNIFORM1IEXT glProgramUniform1iEXT = nullptr;
PFNGLPROGRAMUNIFORM1IVEXT glProgramUniform1ivEXT = nullptr;
PFNGLPROGRAMUNIFORM1UIEXT glProgramUniform1uiEXT = nullptr;
PFNGLPROGRAMUNIFORM1UIVEXT glProgramUniform1uivEXT = nullptr;
PFNGLPROGRAMUNIFORM2FEXT glProgramUniform2fEXT = nullptr;
PFNGLPROGRAMUNIFORM2FVEXT glProgramUniform2fvEXT = nullptr;
PFNGLPROGRAMUNIFORM2IEXT glProgramUniform2iEXT = nullptr;
PFNGLPROGRAMUNIFORM2IVEXT glProgramUniform2ivEXT = nullptr;
PFNGLPROGRAMUNIFORM2UIEXT glProgramUniform2uiEXT = nullptr;
PFNGLPROGRAMUNIFORM2UIVEXT glProgramUniform2uivEXT = nullptr;
PFNGLPROGRAMUNIFORM3FEXT glProgramUniform3fEXT = nullptr;
PFNGLPROGRAMUNIFORM3FVEXT glProgramUniform3fvEXT = nullptr;
PFNGLPROGRAMUNIFORM3IEXT glProgramUniform3iEXT = nullptr;
PFNGLPROGRAMUNIFORM3IVEXT glProgramUniform3ivEXT = nullptr;
PFNGLPROGRAMUNIFORM3UIEXT glProgramUniform3uiEXT = nullptr;
PFNGLPROGRAMUNIFORM3UIVEXT glProgramUniform3uivEXT = nullptr;
PFNGLPROGRAMUNIFORM4FEXT glProgramUniform4fEXT = nullptr;
PFNGLPROGRAMUNIFORM4FVEXT glProgramUniform4fvEXT = nullptr;
PFNGLPROGRAMUNIFORM4IEXT glProgramUniform4iEXT = nullptr;
PFNGLPROGRAMUNIFORM4IVEXT glProgramUniform4ivEXT = nullptr;
PFNGLPROGRAMUNIFORM4UIEXT glProgramUniform4uiEXT = nullptr;
PFNGLPROGRAMUNIFORM4UIVEXT glProgramUniform4uivEXT = nullptr;
PFNGLPROGRAMUNIFORMHANDLEUI64NV glProgramUniformHandleui64NV = nullptr;
PFNGLPROGRAMUNIFORMHANDLEUI64VNV glProgramUniformHandleui64vNV = nullptr;
PFNGLPROGRAMUNIFORMMATRIX2FVEXT glProgramUniformMatrix2fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX2X3FVEXT glProgramUniformMatrix2x3fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX2X4FVEXT glProgramUniformMatrix2x4fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX3FVEXT glProgramUniformMatrix3fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX3X2FVEXT glProgramUniformMatrix3x2fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX3X4FVEXT glProgramUniformMatrix3x4fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX4FVEXT glProgramUniformMatrix4fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX4X2FVEXT glProgramUniformMatrix4x2fvEXT = nullptr;
PFNGLPROGRAMUNIFORMMATRIX4X3FVEXT glProgramUniformMatrix4x3fvEXT = nullptr;
PFNGLPUSHGROUPMARKEREXT glPushGroupMarkerEXT = nullptr;
PFNGLQUERYCOUNTEREXT glQueryCounterEXT = nullptr;
PFNGLREADBUFFERINDEXEDEXT glReadBufferIndexedEXT = nullptr;
PFNGLREADBUFFERNV glReadBufferNV = nullptr;
PFNGLREADNPIXELSEXT glReadnPixelsEXT = nullptr;
PFNGLREADNPIXELSKHR glReadnPixelsKHR = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLE glRenderbufferStorageMultisampleANGLE = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLE glRenderbufferStorageMultisampleAPPLE = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXT glRenderbufferStorageMultisampleEXT = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG glRenderbufferStorageMultisampleIMG = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLENV glRenderbufferStorageMultisampleNV = nullptr;
PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLE glResolveMultisampleFramebufferAPPLE = nullptr;
PFNGLSAMPLERPARAMETERIIVOES glSamplerParameterIivOES = nullptr;
PFNGLSAMPLERPARAMETERIUIVOES glSamplerParameterIuivOES = nullptr;
PFNGLSCISSORARRAYVNV glScissorArrayvNV = nullptr;
PFNGLSCISSORINDEXEDNV glScissorIndexedNV = nullptr;
PFNGLSCISSORINDEXEDVNV glScissorIndexedvNV = nullptr;
PFNGLSELECTPERFMONITORCOUNTERSAMD glSelectPerfMonitorCountersAMD = nullptr;
PFNGLSETFENCENV glSetFenceNV = nullptr;
PFNGLSTARTTILINGQCOM glStartTilingQCOM = nullptr;
PFNGLSTENCILFILLPATHINSTANCEDNV glStencilFillPathInstancedNV = nullptr;
PFNGLSTENCILFILLPATHNV glStencilFillPathNV = nullptr;
PFNGLSTENCILSTROKEPATHINSTANCEDNV glStencilStrokePathInstancedNV = nullptr;
PFNGLSTENCILSTROKEPATHNV glStencilStrokePathNV = nullptr;
PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNV glStencilThenCoverFillPathInstancedNV = nullptr;
PFNGLSTENCILTHENCOVERFILLPATHNV glStencilThenCoverFillPathNV = nullptr;
PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNV glStencilThenCoverStrokePathInstancedNV = nullptr;
PFNGLSTENCILTHENCOVERSTROKEPATHNV glStencilThenCoverStrokePathNV = nullptr;
PFNGLTESTFENCENV glTestFenceNV = nullptr;
PFNGLTEXBUFFEROES glTexBufferOES = nullptr;
PFNGLTEXBUFFERRANGEOES glTexBufferRangeOES = nullptr;
PFNGLTEXIMAGE3DOES glTexImage3DOES = nullptr;
PFNGLTEXPAGECOMMITMENTARB glTexPageCommitmentARB = nullptr;
PFNGLTEXPARAMETERIIVOES glTexParameterIivOES = nullptr;
PFNGLTEXPARAMETERIUIVOES glTexParameterIuivOES = nullptr;
PFNGLTEXSTORAGE1DEXT glTexStorage1DEXT = nullptr;
PFNGLTEXSTORAGE2DEXT glTexStorage2DEXT = nullptr;
PFNGLTEXSTORAGE3DEXT glTexStorage3DEXT = nullptr;
PFNGLTEXSUBIMAGE3DOES glTexSubImage3DOES = nullptr;
PFNGLTEXTURESTORAGE1DEXT glTextureStorage1DEXT = nullptr;
PFNGLTEXTURESTORAGE2DEXT glTextureStorage2DEXT = nullptr;
PFNGLTEXTURESTORAGE3DEXT glTextureStorage3DEXT = nullptr;
PFNGLTEXTUREVIEWEXT glTextureViewEXT = nullptr;
PFNGLTEXTUREVIEWOES glTextureViewOES = nullptr;
PFNGLTRANSFORMPATHNV glTransformPathNV = nullptr;
PFNGLUNIFORMHANDLEUI64NV glUniformHandleui64NV = nullptr;
PFNGLUNIFORMHANDLEUI64VNV glUniformHandleui64vNV = nullptr;
PFNGLUNIFORMMATRIX2X3FVNV glUniformMatrix2x3fvNV = nullptr;
PFNGLUNIFORMMATRIX2X4FVNV glUniformMatrix2x4fvNV = nullptr;
PFNGLUNIFORMMATRIX3X2FVNV glUniformMatrix3x2fvNV = nullptr;
PFNGLUNIFORMMATRIX3X4FVNV glUniformMatrix3x4fvNV = nullptr;
PFNGLUNIFORMMATRIX4X2FVNV glUniformMatrix4x2fvNV = nullptr;
PFNGLUNIFORMMATRIX4X3FVNV glUniformMatrix4x3fvNV = nullptr;
PFNGLUNMAPBUFFEROES glUnmapBufferOES = nullptr;
PFNGLUSEPROGRAMSTAGESEXT glUseProgramStagesEXT = nullptr;
PFNGLVALIDATEPROGRAMPIPELINEEXT glValidateProgramPipelineEXT = nullptr;
PFNGLVERTEXATTRIBDIVISORANGLE glVertexAttribDivisorANGLE = nullptr;
PFNGLVERTEXATTRIBDIVISOREXT glVertexAttribDivisorEXT = nullptr;
PFNGLVERTEXATTRIBDIVISORNV glVertexAttribDivisorNV = nullptr;
PFNGLVIEWPORTARRAYVNV glViewportArrayvNV = nullptr;
PFNGLVIEWPORTINDEXEDFNV glViewportIndexedfNV = nullptr;
PFNGLVIEWPORTINDEXEDFVNV glViewportIndexedfvNV = nullptr;
PFNGLWAITSYNCAPPLE glWaitSyncAPPLE = nullptr;
PFNGLWEIGHTPATHSNV glWeightPathsNV = nullptr;
PFNGLCOVERAGEMODULATIONNV glCoverageModulationNV = nullptr;
PFNGLCOVERAGEMODULATIONTABLENV glCoverageModulationTableNV = nullptr;
PFNGLFRAGMENTCOVERAGECOLORNV glFragmentCoverageColorNV = nullptr;
PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNV glFramebufferSampleLocationsfvNV = nullptr;
PFNGLGETCOVERAGEMODULATIONTABLENV glGetCoverageModulationTableNV = nullptr;
PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV glNamedFramebufferSampleLocationsfvNV = nullptr;
PFNGLRASTERSAMPLESEXT glRasterSamplesEXT = nullptr;
PFNGLRESOLVEDEPTHVALUESNV glResolveDepthValuesNV = nullptr;
PFNGLSUBPIXELPRECISIONBIASNV glSubpixelPrecisionBiasNV = nullptr;
PFNGLBLENDCOLOR glBlendColor = nullptr;
PFNGLBLENDEQUATION glBlendEquation = nullptr;
PFNGLBLENDEQUATIONSEPARATE glBlendEquationSeparate = nullptr;
PFNGLBLENDFUNC glBlendFunc = nullptr;
PFNGLBLENDFUNCSEPARATE glBlendFuncSeparate = nullptr;
PFNGLDEPTHFUNC glDepthFunc = nullptr;
PFNGLSAMPLECOVERAGE glSampleCoverage = nullptr;
PFNGLSAMPLEMASKI glSampleMaski = nullptr;
PFNGLSCISSOR glScissor = nullptr;
PFNGLSTENCILFUNC glStencilFunc = nullptr;
PFNGLSTENCILFUNCSEPARATE glStencilFuncSeparate = nullptr;
PFNGLSTENCILOP glStencilOp = nullptr;
PFNGLSTENCILOPSEPARATE glStencilOpSeparate = nullptr;
PFNGLBINDFRAMEBUFFER glBindFramebuffer = nullptr;
PFNGLBINDRENDERBUFFER glBindRenderbuffer = nullptr;
PFNGLBLITFRAMEBUFFER glBlitFramebuffer = nullptr;
PFNGLCHECKFRAMEBUFFERSTATUS glCheckFramebufferStatus = nullptr;
PFNGLCLEAR glClear = nullptr;
PFNGLCLEARBUFFERFI glClearBufferfi = nullptr;
PFNGLCLEARBUFFERFV glClearBufferfv = nullptr;
PFNGLCLEARBUFFERIV glClearBufferiv = nullptr;
PFNGLCLEARBUFFERUIV glClearBufferuiv = nullptr;
PFNGLCLEARCOLOR glClearColor = nullptr;
PFNGLCLEARDEPTHF glClearDepthf = nullptr;
PFNGLCLEARSTENCIL glClearStencil = nullptr;
PFNGLCOLORMASK glColorMask = nullptr;
PFNGLDELETEFRAMEBUFFERS glDeleteFramebuffers = nullptr;
PFNGLDELETERENDERBUFFERS glDeleteRenderbuffers = nullptr;
PFNGLDEPTHMASK glDepthMask = nullptr;
PFNGLFRAMEBUFFERPARAMETERI glFramebufferParameteri = nullptr;
PFNGLFRAMEBUFFERRENDERBUFFER glFramebufferRenderbuffer = nullptr;
PFNGLFRAMEBUFFERTEXTURE2D glFramebufferTexture2D = nullptr;
PFNGLFRAMEBUFFERTEXTURELAYER glFramebufferTextureLayer = nullptr;
PFNGLGENFRAMEBUFFERS glGenFramebuffers = nullptr;
PFNGLGENRENDERBUFFERS glGenRenderbuffers = nullptr;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV glGetFramebufferAttachmentParameteriv = nullptr;
PFNGLGETFRAMEBUFFERPARAMETERIV glGetFramebufferParameteriv = nullptr;
PFNGLGETRENDERBUFFERPARAMETERIV glGetRenderbufferParameteriv = nullptr;
PFNGLINVALIDATEFRAMEBUFFER glInvalidateFramebuffer = nullptr;
PFNGLINVALIDATESUBFRAMEBUFFER glInvalidateSubFramebuffer = nullptr;
PFNGLISFRAMEBUFFER glIsFramebuffer = nullptr;
PFNGLISRENDERBUFFER glIsRenderbuffer = nullptr;
PFNGLREADBUFFER glReadBuffer = nullptr;
PFNGLREADPIXELS glReadPixels = nullptr;
PFNGLRENDERBUFFERSTORAGE glRenderbufferStorage = nullptr;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLE glRenderbufferStorageMultisample = nullptr;
PFNGLSTENCILMASK glStencilMask = nullptr;
PFNGLSTENCILMASKSEPARATE glStencilMaskSeparate = nullptr;
PFNGLDISABLE glDisable = nullptr;
PFNGLENABLE glEnable = nullptr;
PFNGLFINISH glFinish = nullptr;
PFNGLFLUSH glFlush = nullptr;
PFNGLFLUSHMAPPEDBUFFERRANGE glFlushMappedBufferRange = nullptr;
PFNGLGETERROR glGetError = nullptr;
PFNGLHINT glHint = nullptr;
PFNGLACTIVESHADERPROGRAM glActiveShaderProgram = nullptr;
PFNGLATTACHSHADER glAttachShader = nullptr;
PFNGLBINDATTRIBLOCATION glBindAttribLocation = nullptr;
PFNGLBINDPROGRAMPIPELINE glBindProgramPipeline = nullptr;
PFNGLCOMPILESHADER glCompileShader = nullptr;
PFNGLCREATEPROGRAM glCreateProgram = nullptr;
PFNGLCREATESHADER glCreateShader = nullptr;
PFNGLCREATESHADERPROGRAMV glCreateShaderProgramv = nullptr;
PFNGLDELETEPROGRAM glDeleteProgram = nullptr;
PFNGLDELETEPROGRAMPIPELINES glDeleteProgramPipelines = nullptr;
PFNGLDELETESHADER glDeleteShader = nullptr;
PFNGLDETACHSHADER glDetachShader = nullptr;
PFNGLDISPATCHCOMPUTE glDispatchCompute = nullptr;
PFNGLDISPATCHCOMPUTEINDIRECT glDispatchComputeIndirect = nullptr;
PFNGLGENPROGRAMPIPELINES glGenProgramPipelines = nullptr;
PFNGLGETACTIVEATTRIB glGetActiveAttrib = nullptr;
PFNGLGETACTIVEUNIFORM glGetActiveUniform = nullptr;
PFNGLGETACTIVEUNIFORMBLOCKNAME glGetActiveUniformBlockName = nullptr;
PFNGLGETACTIVEUNIFORMBLOCKIV glGetActiveUniformBlockiv = nullptr;
PFNGLGETACTIVEUNIFORMSIV glGetActiveUniformsiv = nullptr;
PFNGLGETATTACHEDSHADERS glGetAttachedShaders = nullptr;
PFNGLGETATTRIBLOCATION glGetAttribLocation = nullptr;
PFNGLGETFRAGDATALOCATION glGetFragDataLocation = nullptr;
PFNGLGETPROGRAMBINARY glGetProgramBinary = nullptr;
PFNGLGETPROGRAMINFOLOG glGetProgramInfoLog = nullptr;
PFNGLGETPROGRAMINTERFACEIV glGetProgramInterfaceiv = nullptr;
PFNGLGETPROGRAMPIPELINEINFOLOG glGetProgramPipelineInfoLog = nullptr;
PFNGLGETPROGRAMPIPELINEIV glGetProgramPipelineiv = nullptr;
PFNGLGETPROGRAMRESOURCEINDEX glGetProgramResourceIndex = nullptr;
PFNGLGETPROGRAMRESOURCELOCATION glGetProgramResourceLocation = nullptr;
PFNGLGETPROGRAMRESOURCENAME glGetProgramResourceName = nullptr;
PFNGLGETPROGRAMRESOURCEIV glGetProgramResourceiv = nullptr;
PFNGLGETPROGRAMIV glGetProgramiv = nullptr;
PFNGLGETSHADERINFOLOG glGetShaderInfoLog = nullptr;
PFNGLGETSHADERPRECISIONFORMAT glGetShaderPrecisionFormat = nullptr;
PFNGLGETSHADERSOURCE glGetShaderSource = nullptr;
PFNGLGETSHADERIV glGetShaderiv = nullptr;
PFNGLGETUNIFORMBLOCKINDEX glGetUniformBlockIndex = nullptr;
PFNGLGETUNIFORMINDICES glGetUniformIndices = nullptr;
PFNGLGETUNIFORMLOCATION glGetUniformLocation = nullptr;
PFNGLGETUNIFORMFV glGetUniformfv = nullptr;
PFNGLGETUNIFORMIV glGetUniformiv = nullptr;
PFNGLGETUNIFORMUIV glGetUniformuiv = nullptr;
PFNGLISPROGRAM glIsProgram = nullptr;
PFNGLISPROGRAMPIPELINE glIsProgramPipeline = nullptr;
PFNGLISSHADER glIsShader = nullptr;
PFNGLLINKPROGRAM glLinkProgram = nullptr;
PFNGLMEMORYBARRIER glMemoryBarrier = nullptr;
PFNGLMEMORYBARRIERBYREGION glMemoryBarrierByRegion = nullptr;
PFNGLPROGRAMBINARY glProgramBinary = nullptr;
PFNGLPROGRAMPARAMETERI glProgramParameteri = nullptr;
PFNGLPROGRAMUNIFORM1F glProgramUniform1f = nullptr;
PFNGLPROGRAMUNIFORM1FV glProgramUniform1fv = nullptr;
PFNGLPROGRAMUNIFORM1I glProgramUniform1i = nullptr;
PFNGLPROGRAMUNIFORM1IV glProgramUniform1iv = nullptr;
PFNGLPROGRAMUNIFORM1UI glProgramUniform1ui = nullptr;
PFNGLPROGRAMUNIFORM1UIV glProgramUniform1uiv = nullptr;
PFNGLPROGRAMUNIFORM2F glProgramUniform2f = nullptr;
PFNGLPROGRAMUNIFORM2FV glProgramUniform2fv = nullptr;
PFNGLPROGRAMUNIFORM2I glProgramUniform2i = nullptr;
PFNGLPROGRAMUNIFORM2IV glProgramUniform2iv = nullptr;
PFNGLPROGRAMUNIFORM2UI glProgramUniform2ui = nullptr;
PFNGLPROGRAMUNIFORM2UIV glProgramUniform2uiv = nullptr;
PFNGLPROGRAMUNIFORM3F glProgramUniform3f = nullptr;
PFNGLPROGRAMUNIFORM3FV glProgramUniform3fv = nullptr;
PFNGLPROGRAMUNIFORM3I glProgramUniform3i = nullptr;
PFNGLPROGRAMUNIFORM3IV glProgramUniform3iv = nullptr;
PFNGLPROGRAMUNIFORM3UI glProgramUniform3ui = nullptr;
PFNGLPROGRAMUNIFORM3UIV glProgramUniform3uiv = nullptr;
PFNGLPROGRAMUNIFORM4F glProgramUniform4f = nullptr;
PFNGLPROGRAMUNIFORM4FV glProgramUniform4fv = nullptr;
PFNGLPROGRAMUNIFORM4I glProgramUniform4i = nullptr;
PFNGLPROGRAMUNIFORM4IV glProgramUniform4iv = nullptr;
PFNGLPROGRAMUNIFORM4UI glProgramUniform4ui = nullptr;
PFNGLPROGRAMUNIFORM4UIV glProgramUniform4uiv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX2FV glProgramUniformMatrix2fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX2X3FV glProgramUniformMatrix2x3fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX2X4FV glProgramUniformMatrix2x4fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX3FV glProgramUniformMatrix3fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX3X2FV glProgramUniformMatrix3x2fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX3X4FV glProgramUniformMatrix3x4fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX4FV glProgramUniformMatrix4fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX4X2FV glProgramUniformMatrix4x2fv = nullptr;
PFNGLPROGRAMUNIFORMMATRIX4X3FV glProgramUniformMatrix4x3fv = nullptr;
PFNGLRELEASESHADERCOMPILER glReleaseShaderCompiler = nullptr;
PFNGLSHADERBINARY glShaderBinary = nullptr;
PFNGLSHADERSOURCE glShaderSource = nullptr;
PFNGLUNIFORM1F glUniform1f = nullptr;
PFNGLUNIFORM1FV glUniform1fv = nullptr;
PFNGLUNIFORM1I glUniform1i = nullptr;
PFNGLUNIFORM1IV glUniform1iv = nullptr;
PFNGLUNIFORM1UI glUniform1ui = nullptr;
PFNGLUNIFORM1UIV glUniform1uiv = nullptr;
PFNGLUNIFORM2F glUniform2f = nullptr;
PFNGLUNIFORM2FV glUniform2fv = nullptr;
PFNGLUNIFORM2I glUniform2i = nullptr;
PFNGLUNIFORM2IV glUniform2iv = nullptr;
PFNGLUNIFORM2UI glUniform2ui = nullptr;
PFNGLUNIFORM2UIV glUniform2uiv = nullptr;
PFNGLUNIFORM3F glUniform3f = nullptr;
PFNGLUNIFORM3FV glUniform3fv = nullptr;
PFNGLUNIFORM3I glUniform3i = nullptr;
PFNGLUNIFORM3IV glUniform3iv = nullptr;
PFNGLUNIFORM3UI glUniform3ui = nullptr;
PFNGLUNIFORM3UIV glUniform3uiv = nullptr;
PFNGLUNIFORM4F glUniform4f = nullptr;
PFNGLUNIFORM4FV glUniform4fv = nullptr;
PFNGLUNIFORM4I glUniform4i = nullptr;
PFNGLUNIFORM4IV glUniform4iv = nullptr;
PFNGLUNIFORM4UI glUniform4ui = nullptr;
PFNGLUNIFORM4UIV glUniform4uiv = nullptr;
PFNGLUNIFORMBLOCKBINDING glUniformBlockBinding = nullptr;
PFNGLUNIFORMMATRIX2FV glUniformMatrix2fv = nullptr;
PFNGLUNIFORMMATRIX2X3FV glUniformMatrix2x3fv = nullptr;
PFNGLUNIFORMMATRIX2X4FV glUniformMatrix2x4fv = nullptr;
PFNGLUNIFORMMATRIX3FV glUniformMatrix3fv = nullptr;
PFNGLUNIFORMMATRIX3X2FV glUniformMatrix3x2fv = nullptr;
PFNGLUNIFORMMATRIX3X4FV glUniformMatrix3x4fv = nullptr;
PFNGLUNIFORMMATRIX4FV glUniformMatrix4fv = nullptr;
PFNGLUNIFORMMATRIX4X2FV glUniformMatrix4x2fv = nullptr;
PFNGLUNIFORMMATRIX4X3FV glUniformMatrix4x3fv = nullptr;
PFNGLUSEPROGRAM glUseProgram = nullptr;
PFNGLUSEPROGRAMSTAGES glUseProgramStages = nullptr;
PFNGLVALIDATEPROGRAM glValidateProgram = nullptr;
PFNGLVALIDATEPROGRAMPIPELINE glValidateProgramPipeline = nullptr;
PFNGLCULLFACE glCullFace = nullptr;
PFNGLDEPTHRANGEF glDepthRangef = nullptr;
PFNGLFRONTFACE glFrontFace = nullptr;
PFNGLGETMULTISAMPLEFV glGetMultisamplefv = nullptr;
PFNGLLINEWIDTH glLineWidth = nullptr;
PFNGLPOLYGONOFFSET glPolygonOffset = nullptr;
PFNGLVIEWPORT glViewport = nullptr;
PFNGLGETBOOLEANI_V glGetBooleani_v = nullptr;
PFNGLGETBOOLEANV glGetBooleanv = nullptr;
PFNGLGETFLOATV glGetFloatv = nullptr;
PFNGLGETINTEGER64I_V glGetInteger64i_v = nullptr;
PFNGLGETINTEGER64V glGetInteger64v = nullptr;
PFNGLGETINTEGERI_V glGetIntegeri_v = nullptr;
PFNGLGETINTEGERV glGetIntegerv = nullptr;
PFNGLGETINTERNALFORMATIV glGetInternalformativ = nullptr;
PFNGLGETSTRING glGetString = nullptr;
PFNGLGETSTRINGI glGetStringi = nullptr;
PFNGLISENABLED glIsEnabled = nullptr;
PFNGLCLIENTWAITSYNC glClientWaitSync = nullptr;
PFNGLDELETESYNC glDeleteSync = nullptr;
PFNGLFENCESYNC glFenceSync = nullptr;
PFNGLGETSYNCIV glGetSynciv = nullptr;
PFNGLISSYNC glIsSync = nullptr;
PFNGLWAITSYNC glWaitSync = nullptr;
PFNGLACTIVETEXTURE glActiveTexture = nullptr;
PFNGLBINDIMAGETEXTURE glBindImageTexture = nullptr;
PFNGLBINDSAMPLER glBindSampler = nullptr;
PFNGLBINDTEXTURE glBindTexture = nullptr;
PFNGLCOMPRESSEDTEXIMAGE2D glCompressedTexImage2D = nullptr;
PFNGLCOMPRESSEDTEXIMAGE3D glCompressedTexImage3D = nullptr;
PFNGLCOMPRESSEDTEXSUBIMAGE2D glCompressedTexSubImage2D = nullptr;
PFNGLCOMPRESSEDTEXSUBIMAGE3D glCompressedTexSubImage3D = nullptr;
PFNGLCOPYTEXIMAGE2D glCopyTexImage2D = nullptr;
PFNGLCOPYTEXSUBIMAGE2D glCopyTexSubImage2D = nullptr;
PFNGLCOPYTEXSUBIMAGE3D glCopyTexSubImage3D = nullptr;
PFNGLDELETESAMPLERS glDeleteSamplers = nullptr;
PFNGLDELETETEXTURES glDeleteTextures = nullptr;
PFNGLGENSAMPLERS glGenSamplers = nullptr;
PFNGLGENTEXTURES glGenTextures = nullptr;
PFNGLGENERATEMIPMAP glGenerateMipmap = nullptr;
PFNGLGETSAMPLERPARAMETERFV glGetSamplerParameterfv = nullptr;
PFNGLGETSAMPLERPARAMETERIV glGetSamplerParameteriv = nullptr;
PFNGLGETTEXLEVELPARAMETERFV glGetTexLevelParameterfv = nullptr;
PFNGLGETTEXLEVELPARAMETERIV glGetTexLevelParameteriv = nullptr;
PFNGLGETTEXPARAMETERFV glGetTexParameterfv = nullptr;
PFNGLGETTEXPARAMETERIV glGetTexParameteriv = nullptr;
PFNGLISSAMPLER glIsSampler = nullptr;
PFNGLISTEXTURE glIsTexture = nullptr;
PFNGLPIXELSTOREI glPixelStorei = nullptr;
PFNGLSAMPLERPARAMETERF glSamplerParameterf = nullptr;
PFNGLSAMPLERPARAMETERFV glSamplerParameterfv = nullptr;
PFNGLSAMPLERPARAMETERI glSamplerParameteri = nullptr;
PFNGLSAMPLERPARAMETERIV glSamplerParameteriv = nullptr;
PFNGLTEXIMAGE2D glTexImage2D = nullptr;
PFNGLTEXIMAGE3D glTexImage3D = nullptr;
PFNGLTEXPARAMETERF glTexParameterf = nullptr;
PFNGLTEXPARAMETERFV glTexParameterfv = nullptr;
PFNGLTEXPARAMETERI glTexParameteri = nullptr;
PFNGLTEXPARAMETERIV glTexParameteriv = nullptr;
PFNGLTEXSTORAGE2D glTexStorage2D = nullptr;
PFNGLTEXSTORAGE2DMULTISAMPLE glTexStorage2DMultisample = nullptr;
PFNGLTEXSTORAGE3D glTexStorage3D = nullptr;
PFNGLTEXSUBIMAGE2D glTexSubImage2D = nullptr;
PFNGLTEXSUBIMAGE3D glTexSubImage3D = nullptr;
PFNGLBEGINTRANSFORMFEEDBACK glBeginTransformFeedback = nullptr;
PFNGLBINDTRANSFORMFEEDBACK glBindTransformFeedback = nullptr;
PFNGLDELETETRANSFORMFEEDBACKS glDeleteTransformFeedbacks = nullptr;
PFNGLENDTRANSFORMFEEDBACK glEndTransformFeedback = nullptr;
PFNGLGENTRANSFORMFEEDBACKS glGenTransformFeedbacks = nullptr;
PFNGLGETTRANSFORMFEEDBACKVARYING glGetTransformFeedbackVarying = nullptr;
PFNGLISTRANSFORMFEEDBACK glIsTransformFeedback = nullptr;
PFNGLPAUSETRANSFORMFEEDBACK glPauseTransformFeedback = nullptr;
PFNGLRESUMETRANSFORMFEEDBACK glResumeTransformFeedback = nullptr;
PFNGLTRANSFORMFEEDBACKVARYINGS glTransformFeedbackVaryings = nullptr;
PFNGLBINDVERTEXARRAY glBindVertexArray = nullptr;
PFNGLBINDVERTEXBUFFER glBindVertexBuffer = nullptr;
PFNGLDELETEVERTEXARRAYS glDeleteVertexArrays = nullptr;
PFNGLDISABLEVERTEXATTRIBARRAY glDisableVertexAttribArray = nullptr;
PFNGLENABLEVERTEXATTRIBARRAY glEnableVertexAttribArray = nullptr;
PFNGLGENVERTEXARRAYS glGenVertexArrays = nullptr;
PFNGLGETVERTEXATTRIBIIV glGetVertexAttribIiv = nullptr;
PFNGLGETVERTEXATTRIBIUIV glGetVertexAttribIuiv = nullptr;
PFNGLGETVERTEXATTRIBPOINTERV glGetVertexAttribPointerv = nullptr;
PFNGLGETVERTEXATTRIBFV glGetVertexAttribfv = nullptr;
PFNGLGETVERTEXATTRIBIV glGetVertexAttribiv = nullptr;
PFNGLISVERTEXARRAY glIsVertexArray = nullptr;
PFNGLVERTEXATTRIB1F glVertexAttrib1f = nullptr;
PFNGLVERTEXATTRIB1FV glVertexAttrib1fv = nullptr;
PFNGLVERTEXATTRIB2F glVertexAttrib2f = nullptr;
PFNGLVERTEXATTRIB2FV glVertexAttrib2fv = nullptr;
PFNGLVERTEXATTRIB3F glVertexAttrib3f = nullptr;
PFNGLVERTEXATTRIB3FV glVertexAttrib3fv = nullptr;
PFNGLVERTEXATTRIB4F glVertexAttrib4f = nullptr;
PFNGLVERTEXATTRIB4FV glVertexAttrib4fv = nullptr;
PFNGLVERTEXATTRIBBINDING glVertexAttribBinding = nullptr;
PFNGLVERTEXATTRIBDIVISOR glVertexAttribDivisor = nullptr;
PFNGLVERTEXATTRIBFORMAT glVertexAttribFormat = nullptr;
PFNGLVERTEXATTRIBI4I glVertexAttribI4i = nullptr;
PFNGLVERTEXATTRIBI4IV glVertexAttribI4iv = nullptr;
PFNGLVERTEXATTRIBI4UI glVertexAttribI4ui = nullptr;
PFNGLVERTEXATTRIBI4UIV glVertexAttribI4uiv = nullptr;
PFNGLVERTEXATTRIBIFORMAT glVertexAttribIFormat = nullptr;
PFNGLVERTEXATTRIBIPOINTER glVertexAttribIPointer = nullptr;
PFNGLVERTEXATTRIBPOINTER glVertexAttribPointer = nullptr;
PFNGLVERTEXBINDINGDIVISOR glVertexBindingDivisor = nullptr;
PFNEGLINITIALIZE eglInitialize = nullptr;
PFNEGLCREATECONTEXT eglCreateContext = nullptr;
PFNEGLMAKECURRENT eglMakeCurrent = nullptr;
PFNEGLSWAPBUFFERS eglSwapBuffers = nullptr;
PFNEGLQUERYSURFACE eglQuerySurface = nullptr;
PFNGLXCREATECONTEXT glXCreateContext = nullptr;
PFNGLXCREATENEWCONTEXT glXCreateNewContext = nullptr;
PFNGLXMAKECONTEXTCURRENT glXMakeContextCurrent = nullptr;
PFNGLXMAKECURRENT glXMakeCurrent = nullptr;
PFNGLXSWAPBUFFERS glXSwapBuffers = nullptr;
PFNGLXQUERYDRAWABLE glXQueryDrawable = nullptr;
PFNWGLCREATECONTEXT wglCreateContext = nullptr;
PFNWGLCREATECONTEXTATTRIBSARB wglCreateContextAttribsARB = nullptr;
PFNWGLMAKECURRENT wglMakeCurrent = nullptr;
PFNWGLSWAPBUFFERS wglSwapBuffers = nullptr;
PFNCGLCREATECONTEXT CGLCreateContext = nullptr;
PFNCGLSETCURRENTCONTEXT CGLSetCurrentContext = nullptr;
PFNCGLGETSURFACE CGLGetSurface = nullptr;
PFNCGSGETSURFACEBOUNDS CGSGetSurfaceBounds = nullptr;
PFNCGLFLUSHDRAWABLE CGLFlushDrawable = nullptr;
PFNGLGETQUERYOBJECTI64V glGetQueryObjecti64v = nullptr;
PFNGLGETQUERYOBJECTUI64V glGetQueryObjectui64v = nullptr;

void Register(Interpreter* interpreter) {
    interpreter->registerFunction(Ids::GlBlendBarrierKHR, callGlBlendBarrierKHR);
    interpreter->registerFunction(Ids::GlBlendEquationSeparateiEXT,
                                  callGlBlendEquationSeparateiEXT);
    interpreter->registerFunction(Ids::GlBlendEquationiEXT, callGlBlendEquationiEXT);
    interpreter->registerFunction(Ids::GlBlendFuncSeparateiEXT, callGlBlendFuncSeparateiEXT);
    interpreter->registerFunction(Ids::GlBlendFunciEXT, callGlBlendFunciEXT);
    interpreter->registerFunction(Ids::GlColorMaskiEXT, callGlColorMaskiEXT);
    interpreter->registerFunction(Ids::GlCopyImageSubDataEXT, callGlCopyImageSubDataEXT);
    interpreter->registerFunction(Ids::GlDebugMessageCallbackKHR, callGlDebugMessageCallbackKHR);
    interpreter->registerFunction(Ids::GlDebugMessageControlKHR, callGlDebugMessageControlKHR);
    interpreter->registerFunction(Ids::GlDebugMessageInsertKHR, callGlDebugMessageInsertKHR);
    interpreter->registerFunction(Ids::GlDisableiEXT, callGlDisableiEXT);
    interpreter->registerFunction(Ids::GlEnableiEXT, callGlEnableiEXT);
    interpreter->registerFunction(Ids::GlFramebufferTextureEXT, callGlFramebufferTextureEXT);
    interpreter->registerFunction(Ids::GlGetDebugMessageLogKHR, callGlGetDebugMessageLogKHR);
    interpreter->registerFunction(Ids::GlGetObjectLabelKHR, callGlGetObjectLabelKHR);
    interpreter->registerFunction(Ids::GlGetObjectPtrLabelKHR, callGlGetObjectPtrLabelKHR);
    interpreter->registerFunction(Ids::GlGetPointervKHR, callGlGetPointervKHR);
    interpreter->registerFunction(Ids::GlGetSamplerParameterIivEXT,
                                  callGlGetSamplerParameterIivEXT);
    interpreter->registerFunction(Ids::GlGetSamplerParameterIuivEXT,
                                  callGlGetSamplerParameterIuivEXT);
    interpreter->registerFunction(Ids::GlGetTexParameterIivEXT, callGlGetTexParameterIivEXT);
    interpreter->registerFunction(Ids::GlGetTexParameterIuivEXT, callGlGetTexParameterIuivEXT);
    interpreter->registerFunction(Ids::GlIsEnablediEXT, callGlIsEnablediEXT);
    interpreter->registerFunction(Ids::GlMinSampleShadingOES, callGlMinSampleShadingOES);
    interpreter->registerFunction(Ids::GlObjectLabelKHR, callGlObjectLabelKHR);
    interpreter->registerFunction(Ids::GlObjectPtrLabelKHR, callGlObjectPtrLabelKHR);
    interpreter->registerFunction(Ids::GlPatchParameteriEXT, callGlPatchParameteriEXT);
    interpreter->registerFunction(Ids::GlPopDebugGroupKHR, callGlPopDebugGroupKHR);
    interpreter->registerFunction(Ids::GlPrimitiveBoundingBoxEXT, callGlPrimitiveBoundingBoxEXT);
    interpreter->registerFunction(Ids::GlPushDebugGroupKHR, callGlPushDebugGroupKHR);
    interpreter->registerFunction(Ids::GlSamplerParameterIivEXT, callGlSamplerParameterIivEXT);
    interpreter->registerFunction(Ids::GlSamplerParameterIuivEXT, callGlSamplerParameterIuivEXT);
    interpreter->registerFunction(Ids::GlTexBufferEXT, callGlTexBufferEXT);
    interpreter->registerFunction(Ids::GlTexBufferRangeEXT, callGlTexBufferRangeEXT);
    interpreter->registerFunction(Ids::GlTexParameterIivEXT, callGlTexParameterIivEXT);
    interpreter->registerFunction(Ids::GlTexParameterIuivEXT, callGlTexParameterIuivEXT);
    interpreter->registerFunction(Ids::GlTexStorage3DMultisampleOES,
                                  callGlTexStorage3DMultisampleOES);
    interpreter->registerFunction(Ids::GlBeginQuery, callGlBeginQuery);
    interpreter->registerFunction(Ids::GlDeleteQueries, callGlDeleteQueries);
    interpreter->registerFunction(Ids::GlEndQuery, callGlEndQuery);
    interpreter->registerFunction(Ids::GlGenQueries, callGlGenQueries);
    interpreter->registerFunction(Ids::GlGetQueryObjectuiv, callGlGetQueryObjectuiv);
    interpreter->registerFunction(Ids::GlGetQueryiv, callGlGetQueryiv);
    interpreter->registerFunction(Ids::GlIsQuery, callGlIsQuery);
    interpreter->registerFunction(Ids::GlBindBuffer, callGlBindBuffer);
    interpreter->registerFunction(Ids::GlBindBufferBase, callGlBindBufferBase);
    interpreter->registerFunction(Ids::GlBindBufferRange, callGlBindBufferRange);
    interpreter->registerFunction(Ids::GlBufferData, callGlBufferData);
    interpreter->registerFunction(Ids::GlBufferSubData, callGlBufferSubData);
    interpreter->registerFunction(Ids::GlCopyBufferSubData, callGlCopyBufferSubData);
    interpreter->registerFunction(Ids::GlDeleteBuffers, callGlDeleteBuffers);
    interpreter->registerFunction(Ids::GlGenBuffers, callGlGenBuffers);
    interpreter->registerFunction(Ids::GlGetBufferParameteri64v, callGlGetBufferParameteri64v);
    interpreter->registerFunction(Ids::GlGetBufferParameteriv, callGlGetBufferParameteriv);
    interpreter->registerFunction(Ids::GlGetBufferPointerv, callGlGetBufferPointerv);
    interpreter->registerFunction(Ids::GlIsBuffer, callGlIsBuffer);
    interpreter->registerFunction(Ids::GlMapBufferRange, callGlMapBufferRange);
    interpreter->registerFunction(Ids::GlUnmapBuffer, callGlUnmapBuffer);
    interpreter->registerFunction(Ids::GlDrawArrays, callGlDrawArrays);
    interpreter->registerFunction(Ids::GlDrawArraysIndirect, callGlDrawArraysIndirect);
    interpreter->registerFunction(Ids::GlDrawArraysInstanced, callGlDrawArraysInstanced);
    interpreter->registerFunction(Ids::GlDrawBuffers, callGlDrawBuffers);
    interpreter->registerFunction(Ids::GlDrawElements, callGlDrawElements);
    interpreter->registerFunction(Ids::GlDrawElementsIndirect, callGlDrawElementsIndirect);
    interpreter->registerFunction(Ids::GlDrawElementsInstanced, callGlDrawElementsInstanced);
    interpreter->registerFunction(Ids::GlDrawRangeElements, callGlDrawRangeElements);
    interpreter->registerFunction(Ids::GlActiveShaderProgramEXT, callGlActiveShaderProgramEXT);
    interpreter->registerFunction(Ids::GlAlphaFuncQCOM, callGlAlphaFuncQCOM);
    interpreter->registerFunction(Ids::GlBeginConditionalRenderNV, callGlBeginConditionalRenderNV);
    interpreter->registerFunction(Ids::GlBeginPerfMonitorAMD, callGlBeginPerfMonitorAMD);
    interpreter->registerFunction(Ids::GlBeginPerfQueryINTEL, callGlBeginPerfQueryINTEL);
    interpreter->registerFunction(Ids::GlBeginQueryEXT, callGlBeginQueryEXT);
    interpreter->registerFunction(Ids::GlBindProgramPipelineEXT, callGlBindProgramPipelineEXT);
    interpreter->registerFunction(Ids::GlBindVertexArrayOES, callGlBindVertexArrayOES);
    interpreter->registerFunction(Ids::GlBlendBarrierNV, callGlBlendBarrierNV);
    interpreter->registerFunction(Ids::GlBlendEquationSeparateiOES,
                                  callGlBlendEquationSeparateiOES);
    interpreter->registerFunction(Ids::GlBlendEquationiOES, callGlBlendEquationiOES);
    interpreter->registerFunction(Ids::GlBlendFuncSeparateiOES, callGlBlendFuncSeparateiOES);
    interpreter->registerFunction(Ids::GlBlendFunciOES, callGlBlendFunciOES);
    interpreter->registerFunction(Ids::GlBlendParameteriNV, callGlBlendParameteriNV);
    interpreter->registerFunction(Ids::GlBlitFramebufferANGLE, callGlBlitFramebufferANGLE);
    interpreter->registerFunction(Ids::GlBlitFramebufferNV, callGlBlitFramebufferNV);
    interpreter->registerFunction(Ids::GlBufferStorageEXT, callGlBufferStorageEXT);
    interpreter->registerFunction(Ids::GlClientWaitSyncAPPLE, callGlClientWaitSyncAPPLE);
    interpreter->registerFunction(Ids::GlColorMaskiOES, callGlColorMaskiOES);
    interpreter->registerFunction(Ids::GlCompressedTexImage3DOES, callGlCompressedTexImage3DOES);
    interpreter->registerFunction(Ids::GlCompressedTexSubImage3DOES,
                                  callGlCompressedTexSubImage3DOES);
    interpreter->registerFunction(Ids::GlCopyBufferSubDataNV, callGlCopyBufferSubDataNV);
    interpreter->registerFunction(Ids::GlCopyImageSubDataOES, callGlCopyImageSubDataOES);
    interpreter->registerFunction(Ids::GlCopyPathNV, callGlCopyPathNV);
    interpreter->registerFunction(Ids::GlCopyTexSubImage3DOES, callGlCopyTexSubImage3DOES);
    interpreter->registerFunction(Ids::GlCopyTextureLevelsAPPLE, callGlCopyTextureLevelsAPPLE);
    interpreter->registerFunction(Ids::GlCoverFillPathInstancedNV, callGlCoverFillPathInstancedNV);
    interpreter->registerFunction(Ids::GlCoverFillPathNV, callGlCoverFillPathNV);
    interpreter->registerFunction(Ids::GlCoverStrokePathInstancedNV,
                                  callGlCoverStrokePathInstancedNV);
    interpreter->registerFunction(Ids::GlCoverStrokePathNV, callGlCoverStrokePathNV);
    interpreter->registerFunction(Ids::GlCoverageMaskNV, callGlCoverageMaskNV);
    interpreter->registerFunction(Ids::GlCoverageOperationNV, callGlCoverageOperationNV);
    interpreter->registerFunction(Ids::GlCreatePerfQueryINTEL, callGlCreatePerfQueryINTEL);
    interpreter->registerFunction(Ids::GlCreateShaderProgramvEXT, callGlCreateShaderProgramvEXT);
    interpreter->registerFunction(Ids::GlDeleteFencesNV, callGlDeleteFencesNV);
    interpreter->registerFunction(Ids::GlDeletePathsNV, callGlDeletePathsNV);
    interpreter->registerFunction(Ids::GlDeletePerfMonitorsAMD, callGlDeletePerfMonitorsAMD);
    interpreter->registerFunction(Ids::GlDeletePerfQueryINTEL, callGlDeletePerfQueryINTEL);
    interpreter->registerFunction(Ids::GlDeleteProgramPipelinesEXT,
                                  callGlDeleteProgramPipelinesEXT);
    interpreter->registerFunction(Ids::GlDeleteQueriesEXT, callGlDeleteQueriesEXT);
    interpreter->registerFunction(Ids::GlDeleteSyncAPPLE, callGlDeleteSyncAPPLE);
    interpreter->registerFunction(Ids::GlDeleteVertexArraysOES, callGlDeleteVertexArraysOES);
    interpreter->registerFunction(Ids::GlDepthRangeArrayfvNV, callGlDepthRangeArrayfvNV);
    interpreter->registerFunction(Ids::GlDepthRangeIndexedfNV, callGlDepthRangeIndexedfNV);
    interpreter->registerFunction(Ids::GlDisableDriverControlQCOM, callGlDisableDriverControlQCOM);
    interpreter->registerFunction(Ids::GlDisableiNV, callGlDisableiNV);
    interpreter->registerFunction(Ids::GlDisableiOES, callGlDisableiOES);
    interpreter->registerFunction(Ids::GlDiscardFramebufferEXT, callGlDiscardFramebufferEXT);
    interpreter->registerFunction(Ids::GlDrawArraysInstancedANGLE, callGlDrawArraysInstancedANGLE);
    interpreter->registerFunction(Ids::GlDrawArraysInstancedBaseInstanceEXT,
                                  callGlDrawArraysInstancedBaseInstanceEXT);
    interpreter->registerFunction(Ids::GlDrawArraysInstancedEXT, callGlDrawArraysInstancedEXT);
    interpreter->registerFunction(Ids::GlDrawArraysInstancedNV, callGlDrawArraysInstancedNV);
    interpreter->registerFunction(Ids::GlDrawBuffersEXT, callGlDrawBuffersEXT);
    interpreter->registerFunction(Ids::GlDrawBuffersIndexedEXT, callGlDrawBuffersIndexedEXT);
    interpreter->registerFunction(Ids::GlDrawBuffersNV, callGlDrawBuffersNV);
    interpreter->registerFunction(Ids::GlDrawElementsBaseVertexEXT,
                                  callGlDrawElementsBaseVertexEXT);
    interpreter->registerFunction(Ids::GlDrawElementsBaseVertexOES,
                                  callGlDrawElementsBaseVertexOES);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedANGLE,
                                  callGlDrawElementsInstancedANGLE);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedBaseInstanceEXT,
                                  callGlDrawElementsInstancedBaseInstanceEXT);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedBaseVertexEXT,
                                  callGlDrawElementsInstancedBaseVertexEXT);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedBaseVertexOES,
                                  callGlDrawElementsInstancedBaseVertexOES);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedBaseVertexBaseInstanceEXT,
                                  callGlDrawElementsInstancedBaseVertexBaseInstanceEXT);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedEXT, callGlDrawElementsInstancedEXT);
    interpreter->registerFunction(Ids::GlDrawElementsInstancedNV, callGlDrawElementsInstancedNV);
    interpreter->registerFunction(Ids::GlDrawRangeElementsBaseVertexEXT,
                                  callGlDrawRangeElementsBaseVertexEXT);
    interpreter->registerFunction(Ids::GlDrawRangeElementsBaseVertexOES,
                                  callGlDrawRangeElementsBaseVertexOES);
    interpreter->registerFunction(Ids::GlEGLImageTargetRenderbufferStorageOES,
                                  callGlEGLImageTargetRenderbufferStorageOES);
    interpreter->registerFunction(Ids::GlEGLImageTargetTexture2DOES,
                                  callGlEGLImageTargetTexture2DOES);
    interpreter->registerFunction(Ids::GlEnableDriverControlQCOM, callGlEnableDriverControlQCOM);
    interpreter->registerFunction(Ids::GlEnableiNV, callGlEnableiNV);
    interpreter->registerFunction(Ids::GlEnableiOES, callGlEnableiOES);
    interpreter->registerFunction(Ids::GlEndConditionalRenderNV, callGlEndConditionalRenderNV);
    interpreter->registerFunction(Ids::GlEndPerfMonitorAMD, callGlEndPerfMonitorAMD);
    interpreter->registerFunction(Ids::GlEndPerfQueryINTEL, callGlEndPerfQueryINTEL);
    interpreter->registerFunction(Ids::GlEndQueryEXT, callGlEndQueryEXT);
    interpreter->registerFunction(Ids::GlEndTilingQCOM, callGlEndTilingQCOM);
    interpreter->registerFunction(Ids::GlExtGetBufferPointervQCOM, callGlExtGetBufferPointervQCOM);
    interpreter->registerFunction(Ids::GlExtGetBuffersQCOM, callGlExtGetBuffersQCOM);
    interpreter->registerFunction(Ids::GlExtGetFramebuffersQCOM, callGlExtGetFramebuffersQCOM);
    interpreter->registerFunction(Ids::GlExtGetProgramBinarySourceQCOM,
                                  callGlExtGetProgramBinarySourceQCOM);
    interpreter->registerFunction(Ids::GlExtGetProgramsQCOM, callGlExtGetProgramsQCOM);
    interpreter->registerFunction(Ids::GlExtGetRenderbuffersQCOM, callGlExtGetRenderbuffersQCOM);
    interpreter->registerFunction(Ids::GlExtGetShadersQCOM, callGlExtGetShadersQCOM);
    interpreter->registerFunction(Ids::GlExtGetTexLevelParameterivQCOM,
                                  callGlExtGetTexLevelParameterivQCOM);
    interpreter->registerFunction(Ids::GlExtGetTexSubImageQCOM, callGlExtGetTexSubImageQCOM);
    interpreter->registerFunction(Ids::GlExtGetTexturesQCOM, callGlExtGetTexturesQCOM);
    interpreter->registerFunction(Ids::GlExtIsProgramBinaryQCOM, callGlExtIsProgramBinaryQCOM);
    interpreter->registerFunction(Ids::GlExtTexObjectStateOverrideiQCOM,
                                  callGlExtTexObjectStateOverrideiQCOM);
    interpreter->registerFunction(Ids::GlFenceSyncAPPLE, callGlFenceSyncAPPLE);
    interpreter->registerFunction(Ids::GlFinishFenceNV, callGlFinishFenceNV);
    interpreter->registerFunction(Ids::GlFlushMappedBufferRangeEXT,
                                  callGlFlushMappedBufferRangeEXT);
    interpreter->registerFunction(Ids::GlFramebufferTexture2DMultisampleEXT,
                                  callGlFramebufferTexture2DMultisampleEXT);
    interpreter->registerFunction(Ids::GlFramebufferTexture2DMultisampleIMG,
                                  callGlFramebufferTexture2DMultisampleIMG);
    interpreter->registerFunction(Ids::GlFramebufferTexture3DOES, callGlFramebufferTexture3DOES);
    interpreter->registerFunction(Ids::GlFramebufferTextureOES, callGlFramebufferTextureOES);
    interpreter->registerFunction(Ids::GlFramebufferTextureMultiviewOVR,
                                  callGlFramebufferTextureMultiviewOVR);
    interpreter->registerFunction(Ids::GlGenFencesNV, callGlGenFencesNV);
    interpreter->registerFunction(Ids::GlGenPathsNV, callGlGenPathsNV);
    interpreter->registerFunction(Ids::GlGenPerfMonitorsAMD, callGlGenPerfMonitorsAMD);
    interpreter->registerFunction(Ids::GlGenProgramPipelinesEXT, callGlGenProgramPipelinesEXT);
    interpreter->registerFunction(Ids::GlGenQueriesEXT, callGlGenQueriesEXT);
    interpreter->registerFunction(Ids::GlGenVertexArraysOES, callGlGenVertexArraysOES);
    interpreter->registerFunction(Ids::GlGetBufferPointervOES, callGlGetBufferPointervOES);
    interpreter->registerFunction(Ids::GlGetDriverControlStringQCOM,
                                  callGlGetDriverControlStringQCOM);
    interpreter->registerFunction(Ids::GlGetDriverControlsQCOM, callGlGetDriverControlsQCOM);
    interpreter->registerFunction(Ids::GlGetFenceivNV, callGlGetFenceivNV);
    interpreter->registerFunction(Ids::GlGetFirstPerfQueryIdINTEL, callGlGetFirstPerfQueryIdINTEL);
    interpreter->registerFunction(Ids::GlGetFloatiVNV, callGlGetFloatiVNV);
    interpreter->registerFunction(Ids::GlGetGraphicsResetStatusEXT,
                                  callGlGetGraphicsResetStatusEXT);
    interpreter->registerFunction(Ids::GlGetGraphicsResetStatusKHR,
                                  callGlGetGraphicsResetStatusKHR);
    interpreter->registerFunction(Ids::GlGetImageHandleNV, callGlGetImageHandleNV);
    interpreter->registerFunction(Ids::GlGetInteger64vAPPLE, callGlGetInteger64vAPPLE);
    interpreter->registerFunction(Ids::GlGetIntegeriVEXT, callGlGetIntegeriVEXT);
    interpreter->registerFunction(Ids::GlGetInternalformatSampleivNV,
                                  callGlGetInternalformatSampleivNV);
    interpreter->registerFunction(Ids::GlGetNextPerfQueryIdINTEL, callGlGetNextPerfQueryIdINTEL);
    interpreter->registerFunction(Ids::GlGetObjectLabelEXT, callGlGetObjectLabelEXT);
    interpreter->registerFunction(Ids::GlGetPathCommandsNV, callGlGetPathCommandsNV);
    interpreter->registerFunction(Ids::GlGetPathCoordsNV, callGlGetPathCoordsNV);
    interpreter->registerFunction(Ids::GlGetPathDashArrayNV, callGlGetPathDashArrayNV);
    interpreter->registerFunction(Ids::GlGetPathLengthNV, callGlGetPathLengthNV);
    interpreter->registerFunction(Ids::GlGetPathMetricRangeNV, callGlGetPathMetricRangeNV);
    interpreter->registerFunction(Ids::GlGetPathMetricsNV, callGlGetPathMetricsNV);
    interpreter->registerFunction(Ids::GlGetPathParameterfvNV, callGlGetPathParameterfvNV);
    interpreter->registerFunction(Ids::GlGetPathParameterivNV, callGlGetPathParameterivNV);
    interpreter->registerFunction(Ids::GlGetPathSpacingNV, callGlGetPathSpacingNV);
    interpreter->registerFunction(Ids::GlGetPerfCounterInfoINTEL, callGlGetPerfCounterInfoINTEL);
    interpreter->registerFunction(Ids::GlGetPerfMonitorCounterDataAMD,
                                  callGlGetPerfMonitorCounterDataAMD);
    interpreter->registerFunction(Ids::GlGetPerfMonitorCounterInfoAMD,
                                  callGlGetPerfMonitorCounterInfoAMD);
    interpreter->registerFunction(Ids::GlGetPerfMonitorCounterStringAMD,
                                  callGlGetPerfMonitorCounterStringAMD);
    interpreter->registerFunction(Ids::GlGetPerfMonitorCountersAMD,
                                  callGlGetPerfMonitorCountersAMD);
    interpreter->registerFunction(Ids::GlGetPerfMonitorGroupStringAMD,
                                  callGlGetPerfMonitorGroupStringAMD);
    interpreter->registerFunction(Ids::GlGetPerfMonitorGroupsAMD, callGlGetPerfMonitorGroupsAMD);
    interpreter->registerFunction(Ids::GlGetPerfQueryDataINTEL, callGlGetPerfQueryDataINTEL);
    interpreter->registerFunction(Ids::GlGetPerfQueryIdByNameINTEL,
                                  callGlGetPerfQueryIdByNameINTEL);
    interpreter->registerFunction(Ids::GlGetPerfQueryInfoINTEL, callGlGetPerfQueryInfoINTEL);
    interpreter->registerFunction(Ids::GlGetProgramBinaryOES, callGlGetProgramBinaryOES);
    interpreter->registerFunction(Ids::GlGetProgramPipelineInfoLogEXT,
                                  callGlGetProgramPipelineInfoLogEXT);
    interpreter->registerFunction(Ids::GlGetProgramPipelineivEXT, callGlGetProgramPipelineivEXT);
    interpreter->registerFunction(Ids::GlGetProgramResourcefvNV, callGlGetProgramResourcefvNV);
    interpreter->registerFunction(Ids::GlGetQueryObjecti64vEXT, callGlGetQueryObjecti64vEXT);
    interpreter->registerFunction(Ids::GlGetQueryObjectivEXT, callGlGetQueryObjectivEXT);
    interpreter->registerFunction(Ids::GlGetQueryObjectui64vEXT, callGlGetQueryObjectui64vEXT);
    interpreter->registerFunction(Ids::GlGetQueryObjectuivEXT, callGlGetQueryObjectuivEXT);
    interpreter->registerFunction(Ids::GlGetQueryivEXT, callGlGetQueryivEXT);
    interpreter->registerFunction(Ids::GlGetSamplerParameterIivOES,
                                  callGlGetSamplerParameterIivOES);
    interpreter->registerFunction(Ids::GlGetSamplerParameterIuivOES,
                                  callGlGetSamplerParameterIuivOES);
    interpreter->registerFunction(Ids::GlGetSyncivAPPLE, callGlGetSyncivAPPLE);
    interpreter->registerFunction(Ids::GlGetTexParameterIivOES, callGlGetTexParameterIivOES);
    interpreter->registerFunction(Ids::GlGetTexParameterIuivOES, callGlGetTexParameterIuivOES);
    interpreter->registerFunction(Ids::GlGetTextureHandleNV, callGlGetTextureHandleNV);
    interpreter->registerFunction(Ids::GlGetTextureSamplerHandleNV,
                                  callGlGetTextureSamplerHandleNV);
    interpreter->registerFunction(Ids::GlGetTranslatedShaderSourceANGLE,
                                  callGlGetTranslatedShaderSourceANGLE);
    interpreter->registerFunction(Ids::GlGetnUniformfvEXT, callGlGetnUniformfvEXT);
    interpreter->registerFunction(Ids::GlGetnUniformfvKHR, callGlGetnUniformfvKHR);
    interpreter->registerFunction(Ids::GlGetnUniformivEXT, callGlGetnUniformivEXT);
    interpreter->registerFunction(Ids::GlGetnUniformivKHR, callGlGetnUniformivKHR);
    interpreter->registerFunction(Ids::GlGetnUniformuivKHR, callGlGetnUniformuivKHR);
    interpreter->registerFunction(Ids::GlInsertEventMarkerEXT, callGlInsertEventMarkerEXT);
    interpreter->registerFunction(Ids::GlInterpolatePathsNV, callGlInterpolatePathsNV);
    interpreter->registerFunction(Ids::GlIsEnablediOES, callGlIsEnablediOES);
    interpreter->registerFunction(Ids::GlIsEnablediNV, callGlIsEnablediNV);
    interpreter->registerFunction(Ids::GlIsFenceNV, callGlIsFenceNV);
    interpreter->registerFunction(Ids::GlIsImageHandleResidentNV, callGlIsImageHandleResidentNV);
    interpreter->registerFunction(Ids::GlIsPathNV, callGlIsPathNV);
    interpreter->registerFunction(Ids::GlIsPointInFillPathNV, callGlIsPointInFillPathNV);
    interpreter->registerFunction(Ids::GlIsPointInStrokePathNV, callGlIsPointInStrokePathNV);
    interpreter->registerFunction(Ids::GlIsProgramPipelineEXT, callGlIsProgramPipelineEXT);
    interpreter->registerFunction(Ids::GlIsQueryEXT, callGlIsQueryEXT);
    interpreter->registerFunction(Ids::GlIsSyncAPPLE, callGlIsSyncAPPLE);
    interpreter->registerFunction(Ids::GlIsTextureHandleResidentNV,
                                  callGlIsTextureHandleResidentNV);
    interpreter->registerFunction(Ids::GlIsVertexArrayOES, callGlIsVertexArrayOES);
    interpreter->registerFunction(Ids::GlLabelObjectEXT, callGlLabelObjectEXT);
    interpreter->registerFunction(Ids::GlMakeImageHandleNonResidentNV,
                                  callGlMakeImageHandleNonResidentNV);
    interpreter->registerFunction(Ids::GlMakeImageHandleResidentNV,
                                  callGlMakeImageHandleResidentNV);
    interpreter->registerFunction(Ids::GlMakeTextureHandleNonResidentNV,
                                  callGlMakeTextureHandleNonResidentNV);
    interpreter->registerFunction(Ids::GlMakeTextureHandleResidentNV,
                                  callGlMakeTextureHandleResidentNV);
    interpreter->registerFunction(Ids::GlMapBufferOES, callGlMapBufferOES);
    interpreter->registerFunction(Ids::GlMapBufferRangeEXT, callGlMapBufferRangeEXT);
    interpreter->registerFunction(Ids::GlMatrixLoad3x2fNV, callGlMatrixLoad3x2fNV);
    interpreter->registerFunction(Ids::GlMatrixLoad3x3fNV, callGlMatrixLoad3x3fNV);
    interpreter->registerFunction(Ids::GlMatrixLoadTranspose3x3fNV,
                                  callGlMatrixLoadTranspose3x3fNV);
    interpreter->registerFunction(Ids::GlMatrixMult3x2fNV, callGlMatrixMult3x2fNV);
    interpreter->registerFunction(Ids::GlMatrixMult3x3fNV, callGlMatrixMult3x3fNV);
    interpreter->registerFunction(Ids::GlMatrixMultTranspose3x3fNV,
                                  callGlMatrixMultTranspose3x3fNV);
    interpreter->registerFunction(Ids::GlMultiDrawArraysEXT, callGlMultiDrawArraysEXT);
    interpreter->registerFunction(Ids::GlMultiDrawArraysIndirectEXT,
                                  callGlMultiDrawArraysIndirectEXT);
    interpreter->registerFunction(Ids::GlMultiDrawElementsBaseVertexEXT,
                                  callGlMultiDrawElementsBaseVertexEXT);
    interpreter->registerFunction(Ids::GlMultiDrawElementsBaseVertexOES,
                                  callGlMultiDrawElementsBaseVertexOES);
    interpreter->registerFunction(Ids::GlMultiDrawElementsEXT, callGlMultiDrawElementsEXT);
    interpreter->registerFunction(Ids::GlMultiDrawElementsIndirectEXT,
                                  callGlMultiDrawElementsIndirectEXT);
    interpreter->registerFunction(Ids::GlPatchParameteriOES, callGlPatchParameteriOES);
    interpreter->registerFunction(Ids::GlPathCommandsNV, callGlPathCommandsNV);
    interpreter->registerFunction(Ids::GlPathCoordsNV, callGlPathCoordsNV);
    interpreter->registerFunction(Ids::GlPathCoverDepthFuncNV, callGlPathCoverDepthFuncNV);
    interpreter->registerFunction(Ids::GlPathDashArrayNV, callGlPathDashArrayNV);
    interpreter->registerFunction(Ids::GlPathGlyphIndexArrayNV, callGlPathGlyphIndexArrayNV);
    interpreter->registerFunction(Ids::GlPathGlyphIndexRangeNV, callGlPathGlyphIndexRangeNV);
    interpreter->registerFunction(Ids::GlPathGlyphRangeNV, callGlPathGlyphRangeNV);
    interpreter->registerFunction(Ids::GlPathGlyphsNV, callGlPathGlyphsNV);
    interpreter->registerFunction(Ids::GlPathMemoryGlyphIndexArrayNV,
                                  callGlPathMemoryGlyphIndexArrayNV);
    interpreter->registerFunction(Ids::GlPathParameterfNV, callGlPathParameterfNV);
    interpreter->registerFunction(Ids::GlPathParameterfvNV, callGlPathParameterfvNV);
    interpreter->registerFunction(Ids::GlPathParameteriNV, callGlPathParameteriNV);
    interpreter->registerFunction(Ids::GlPathParameterivNV, callGlPathParameterivNV);
    interpreter->registerFunction(Ids::GlPathStencilDepthOffsetNV, callGlPathStencilDepthOffsetNV);
    interpreter->registerFunction(Ids::GlPathStencilFuncNV, callGlPathStencilFuncNV);
    interpreter->registerFunction(Ids::GlPathStringNV, callGlPathStringNV);
    interpreter->registerFunction(Ids::GlPathSubCommandsNV, callGlPathSubCommandsNV);
    interpreter->registerFunction(Ids::GlPathSubCoordsNV, callGlPathSubCoordsNV);
    interpreter->registerFunction(Ids::GlPointAlongPathNV, callGlPointAlongPathNV);
    interpreter->registerFunction(Ids::GlPolygonModeNV, callGlPolygonModeNV);
    interpreter->registerFunction(Ids::GlPopGroupMarkerEXT, callGlPopGroupMarkerEXT);
    interpreter->registerFunction(Ids::GlPrimitiveBoundingBoxOES, callGlPrimitiveBoundingBoxOES);
    interpreter->registerFunction(Ids::GlProgramBinaryOES, callGlProgramBinaryOES);
    interpreter->registerFunction(Ids::GlProgramParameteriEXT, callGlProgramParameteriEXT);
    interpreter->registerFunction(Ids::GlProgramPathFragmentInputGenNV,
                                  callGlProgramPathFragmentInputGenNV);
    interpreter->registerFunction(Ids::GlProgramUniform1fEXT, callGlProgramUniform1fEXT);
    interpreter->registerFunction(Ids::GlProgramUniform1fvEXT, callGlProgramUniform1fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniform1iEXT, callGlProgramUniform1iEXT);
    interpreter->registerFunction(Ids::GlProgramUniform1ivEXT, callGlProgramUniform1ivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform1uiEXT, callGlProgramUniform1uiEXT);
    interpreter->registerFunction(Ids::GlProgramUniform1uivEXT, callGlProgramUniform1uivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform2fEXT, callGlProgramUniform2fEXT);
    interpreter->registerFunction(Ids::GlProgramUniform2fvEXT, callGlProgramUniform2fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniform2iEXT, callGlProgramUniform2iEXT);
    interpreter->registerFunction(Ids::GlProgramUniform2ivEXT, callGlProgramUniform2ivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform2uiEXT, callGlProgramUniform2uiEXT);
    interpreter->registerFunction(Ids::GlProgramUniform2uivEXT, callGlProgramUniform2uivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform3fEXT, callGlProgramUniform3fEXT);
    interpreter->registerFunction(Ids::GlProgramUniform3fvEXT, callGlProgramUniform3fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniform3iEXT, callGlProgramUniform3iEXT);
    interpreter->registerFunction(Ids::GlProgramUniform3ivEXT, callGlProgramUniform3ivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform3uiEXT, callGlProgramUniform3uiEXT);
    interpreter->registerFunction(Ids::GlProgramUniform3uivEXT, callGlProgramUniform3uivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform4fEXT, callGlProgramUniform4fEXT);
    interpreter->registerFunction(Ids::GlProgramUniform4fvEXT, callGlProgramUniform4fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniform4iEXT, callGlProgramUniform4iEXT);
    interpreter->registerFunction(Ids::GlProgramUniform4ivEXT, callGlProgramUniform4ivEXT);
    interpreter->registerFunction(Ids::GlProgramUniform4uiEXT, callGlProgramUniform4uiEXT);
    interpreter->registerFunction(Ids::GlProgramUniform4uivEXT, callGlProgramUniform4uivEXT);
    interpreter->registerFunction(Ids::GlProgramUniformHandleui64NV,
                                  callGlProgramUniformHandleui64NV);
    interpreter->registerFunction(Ids::GlProgramUniformHandleui64vNV,
                                  callGlProgramUniformHandleui64vNV);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix2fvEXT,
                                  callGlProgramUniformMatrix2fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix2x3fvEXT,
                                  callGlProgramUniformMatrix2x3fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix2x4fvEXT,
                                  callGlProgramUniformMatrix2x4fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix3fvEXT,
                                  callGlProgramUniformMatrix3fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix3x2fvEXT,
                                  callGlProgramUniformMatrix3x2fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix3x4fvEXT,
                                  callGlProgramUniformMatrix3x4fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix4fvEXT,
                                  callGlProgramUniformMatrix4fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix4x2fvEXT,
                                  callGlProgramUniformMatrix4x2fvEXT);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix4x3fvEXT,
                                  callGlProgramUniformMatrix4x3fvEXT);
    interpreter->registerFunction(Ids::GlPushGroupMarkerEXT, callGlPushGroupMarkerEXT);
    interpreter->registerFunction(Ids::GlQueryCounterEXT, callGlQueryCounterEXT);
    interpreter->registerFunction(Ids::GlReadBufferIndexedEXT, callGlReadBufferIndexedEXT);
    interpreter->registerFunction(Ids::GlReadBufferNV, callGlReadBufferNV);
    interpreter->registerFunction(Ids::GlReadnPixelsEXT, callGlReadnPixelsEXT);
    interpreter->registerFunction(Ids::GlReadnPixelsKHR, callGlReadnPixelsKHR);
    interpreter->registerFunction(Ids::GlRenderbufferStorageMultisampleANGLE,
                                  callGlRenderbufferStorageMultisampleANGLE);
    interpreter->registerFunction(Ids::GlRenderbufferStorageMultisampleAPPLE,
                                  callGlRenderbufferStorageMultisampleAPPLE);
    interpreter->registerFunction(Ids::GlRenderbufferStorageMultisampleEXT,
                                  callGlRenderbufferStorageMultisampleEXT);
    interpreter->registerFunction(Ids::GlRenderbufferStorageMultisampleIMG,
                                  callGlRenderbufferStorageMultisampleIMG);
    interpreter->registerFunction(Ids::GlRenderbufferStorageMultisampleNV,
                                  callGlRenderbufferStorageMultisampleNV);
    interpreter->registerFunction(Ids::GlResolveMultisampleFramebufferAPPLE,
                                  callGlResolveMultisampleFramebufferAPPLE);
    interpreter->registerFunction(Ids::GlSamplerParameterIivOES, callGlSamplerParameterIivOES);
    interpreter->registerFunction(Ids::GlSamplerParameterIuivOES, callGlSamplerParameterIuivOES);
    interpreter->registerFunction(Ids::GlScissorArrayvNV, callGlScissorArrayvNV);
    interpreter->registerFunction(Ids::GlScissorIndexedNV, callGlScissorIndexedNV);
    interpreter->registerFunction(Ids::GlScissorIndexedvNV, callGlScissorIndexedvNV);
    interpreter->registerFunction(Ids::GlSelectPerfMonitorCountersAMD,
                                  callGlSelectPerfMonitorCountersAMD);
    interpreter->registerFunction(Ids::GlSetFenceNV, callGlSetFenceNV);
    interpreter->registerFunction(Ids::GlStartTilingQCOM, callGlStartTilingQCOM);
    interpreter->registerFunction(Ids::GlStencilFillPathInstancedNV,
                                  callGlStencilFillPathInstancedNV);
    interpreter->registerFunction(Ids::GlStencilFillPathNV, callGlStencilFillPathNV);
    interpreter->registerFunction(Ids::GlStencilStrokePathInstancedNV,
                                  callGlStencilStrokePathInstancedNV);
    interpreter->registerFunction(Ids::GlStencilStrokePathNV, callGlStencilStrokePathNV);
    interpreter->registerFunction(Ids::GlStencilThenCoverFillPathInstancedNV,
                                  callGlStencilThenCoverFillPathInstancedNV);
    interpreter->registerFunction(Ids::GlStencilThenCoverFillPathNV,
                                  callGlStencilThenCoverFillPathNV);
    interpreter->registerFunction(Ids::GlStencilThenCoverStrokePathInstancedNV,
                                  callGlStencilThenCoverStrokePathInstancedNV);
    interpreter->registerFunction(Ids::GlStencilThenCoverStrokePathNV,
                                  callGlStencilThenCoverStrokePathNV);
    interpreter->registerFunction(Ids::GlTestFenceNV, callGlTestFenceNV);
    interpreter->registerFunction(Ids::GlTexBufferOES, callGlTexBufferOES);
    interpreter->registerFunction(Ids::GlTexBufferRangeOES, callGlTexBufferRangeOES);
    interpreter->registerFunction(Ids::GlTexImage3DOES, callGlTexImage3DOES);
    interpreter->registerFunction(Ids::GlTexPageCommitmentARB, callGlTexPageCommitmentARB);
    interpreter->registerFunction(Ids::GlTexParameterIivOES, callGlTexParameterIivOES);
    interpreter->registerFunction(Ids::GlTexParameterIuivOES, callGlTexParameterIuivOES);
    interpreter->registerFunction(Ids::GlTexStorage1DEXT, callGlTexStorage1DEXT);
    interpreter->registerFunction(Ids::GlTexStorage2DEXT, callGlTexStorage2DEXT);
    interpreter->registerFunction(Ids::GlTexStorage3DEXT, callGlTexStorage3DEXT);
    interpreter->registerFunction(Ids::GlTexSubImage3DOES, callGlTexSubImage3DOES);
    interpreter->registerFunction(Ids::GlTextureStorage1DEXT, callGlTextureStorage1DEXT);
    interpreter->registerFunction(Ids::GlTextureStorage2DEXT, callGlTextureStorage2DEXT);
    interpreter->registerFunction(Ids::GlTextureStorage3DEXT, callGlTextureStorage3DEXT);
    interpreter->registerFunction(Ids::GlTextureViewEXT, callGlTextureViewEXT);
    interpreter->registerFunction(Ids::GlTextureViewOES, callGlTextureViewOES);
    interpreter->registerFunction(Ids::GlTransformPathNV, callGlTransformPathNV);
    interpreter->registerFunction(Ids::GlUniformHandleui64NV, callGlUniformHandleui64NV);
    interpreter->registerFunction(Ids::GlUniformHandleui64vNV, callGlUniformHandleui64vNV);
    interpreter->registerFunction(Ids::GlUniformMatrix2x3fvNV, callGlUniformMatrix2x3fvNV);
    interpreter->registerFunction(Ids::GlUniformMatrix2x4fvNV, callGlUniformMatrix2x4fvNV);
    interpreter->registerFunction(Ids::GlUniformMatrix3x2fvNV, callGlUniformMatrix3x2fvNV);
    interpreter->registerFunction(Ids::GlUniformMatrix3x4fvNV, callGlUniformMatrix3x4fvNV);
    interpreter->registerFunction(Ids::GlUniformMatrix4x2fvNV, callGlUniformMatrix4x2fvNV);
    interpreter->registerFunction(Ids::GlUniformMatrix4x3fvNV, callGlUniformMatrix4x3fvNV);
    interpreter->registerFunction(Ids::GlUnmapBufferOES, callGlUnmapBufferOES);
    interpreter->registerFunction(Ids::GlUseProgramStagesEXT, callGlUseProgramStagesEXT);
    interpreter->registerFunction(Ids::GlValidateProgramPipelineEXT,
                                  callGlValidateProgramPipelineEXT);
    interpreter->registerFunction(Ids::GlVertexAttribDivisorANGLE, callGlVertexAttribDivisorANGLE);
    interpreter->registerFunction(Ids::GlVertexAttribDivisorEXT, callGlVertexAttribDivisorEXT);
    interpreter->registerFunction(Ids::GlVertexAttribDivisorNV, callGlVertexAttribDivisorNV);
    interpreter->registerFunction(Ids::GlViewportArrayvNV, callGlViewportArrayvNV);
    interpreter->registerFunction(Ids::GlViewportIndexedfNV, callGlViewportIndexedfNV);
    interpreter->registerFunction(Ids::GlViewportIndexedfvNV, callGlViewportIndexedfvNV);
    interpreter->registerFunction(Ids::GlWaitSyncAPPLE, callGlWaitSyncAPPLE);
    interpreter->registerFunction(Ids::GlWeightPathsNV, callGlWeightPathsNV);
    interpreter->registerFunction(Ids::GlCoverageModulationNV, callGlCoverageModulationNV);
    interpreter->registerFunction(Ids::GlCoverageModulationTableNV,
                                  callGlCoverageModulationTableNV);
    interpreter->registerFunction(Ids::GlFragmentCoverageColorNV, callGlFragmentCoverageColorNV);
    interpreter->registerFunction(Ids::GlFramebufferSampleLocationsfvNV,
                                  callGlFramebufferSampleLocationsfvNV);
    interpreter->registerFunction(Ids::GlGetCoverageModulationTableNV,
                                  callGlGetCoverageModulationTableNV);
    interpreter->registerFunction(Ids::GlNamedFramebufferSampleLocationsfvNV,
                                  callGlNamedFramebufferSampleLocationsfvNV);
    interpreter->registerFunction(Ids::GlRasterSamplesEXT, callGlRasterSamplesEXT);
    interpreter->registerFunction(Ids::GlResolveDepthValuesNV, callGlResolveDepthValuesNV);
    interpreter->registerFunction(Ids::GlSubpixelPrecisionBiasNV, callGlSubpixelPrecisionBiasNV);
    interpreter->registerFunction(Ids::GlBlendColor, callGlBlendColor);
    interpreter->registerFunction(Ids::GlBlendEquation, callGlBlendEquation);
    interpreter->registerFunction(Ids::GlBlendEquationSeparate, callGlBlendEquationSeparate);
    interpreter->registerFunction(Ids::GlBlendFunc, callGlBlendFunc);
    interpreter->registerFunction(Ids::GlBlendFuncSeparate, callGlBlendFuncSeparate);
    interpreter->registerFunction(Ids::GlDepthFunc, callGlDepthFunc);
    interpreter->registerFunction(Ids::GlSampleCoverage, callGlSampleCoverage);
    interpreter->registerFunction(Ids::GlSampleMaski, callGlSampleMaski);
    interpreter->registerFunction(Ids::GlScissor, callGlScissor);
    interpreter->registerFunction(Ids::GlStencilFunc, callGlStencilFunc);
    interpreter->registerFunction(Ids::GlStencilFuncSeparate, callGlStencilFuncSeparate);
    interpreter->registerFunction(Ids::GlStencilOp, callGlStencilOp);
    interpreter->registerFunction(Ids::GlStencilOpSeparate, callGlStencilOpSeparate);
    interpreter->registerFunction(Ids::GlBindFramebuffer, callGlBindFramebuffer);
    interpreter->registerFunction(Ids::GlBindRenderbuffer, callGlBindRenderbuffer);
    interpreter->registerFunction(Ids::GlBlitFramebuffer, callGlBlitFramebuffer);
    interpreter->registerFunction(Ids::GlCheckFramebufferStatus, callGlCheckFramebufferStatus);
    interpreter->registerFunction(Ids::GlClear, callGlClear);
    interpreter->registerFunction(Ids::GlClearBufferfi, callGlClearBufferfi);
    interpreter->registerFunction(Ids::GlClearBufferfv, callGlClearBufferfv);
    interpreter->registerFunction(Ids::GlClearBufferiv, callGlClearBufferiv);
    interpreter->registerFunction(Ids::GlClearBufferuiv, callGlClearBufferuiv);
    interpreter->registerFunction(Ids::GlClearColor, callGlClearColor);
    interpreter->registerFunction(Ids::GlClearDepthf, callGlClearDepthf);
    interpreter->registerFunction(Ids::GlClearStencil, callGlClearStencil);
    interpreter->registerFunction(Ids::GlColorMask, callGlColorMask);
    interpreter->registerFunction(Ids::GlDeleteFramebuffers, callGlDeleteFramebuffers);
    interpreter->registerFunction(Ids::GlDeleteRenderbuffers, callGlDeleteRenderbuffers);
    interpreter->registerFunction(Ids::GlDepthMask, callGlDepthMask);
    interpreter->registerFunction(Ids::GlFramebufferParameteri, callGlFramebufferParameteri);
    interpreter->registerFunction(Ids::GlFramebufferRenderbuffer, callGlFramebufferRenderbuffer);
    interpreter->registerFunction(Ids::GlFramebufferTexture2D, callGlFramebufferTexture2D);
    interpreter->registerFunction(Ids::GlFramebufferTextureLayer, callGlFramebufferTextureLayer);
    interpreter->registerFunction(Ids::GlGenFramebuffers, callGlGenFramebuffers);
    interpreter->registerFunction(Ids::GlGenRenderbuffers, callGlGenRenderbuffers);
    interpreter->registerFunction(Ids::GlGetFramebufferAttachmentParameteriv,
                                  callGlGetFramebufferAttachmentParameteriv);
    interpreter->registerFunction(Ids::GlGetFramebufferParameteriv,
                                  callGlGetFramebufferParameteriv);
    interpreter->registerFunction(Ids::GlGetRenderbufferParameteriv,
                                  callGlGetRenderbufferParameteriv);
    interpreter->registerFunction(Ids::GlInvalidateFramebuffer, callGlInvalidateFramebuffer);
    interpreter->registerFunction(Ids::GlInvalidateSubFramebuffer, callGlInvalidateSubFramebuffer);
    interpreter->registerFunction(Ids::GlIsFramebuffer, callGlIsFramebuffer);
    interpreter->registerFunction(Ids::GlIsRenderbuffer, callGlIsRenderbuffer);
    interpreter->registerFunction(Ids::GlReadBuffer, callGlReadBuffer);
    interpreter->registerFunction(Ids::GlReadPixels, callGlReadPixels);
    interpreter->registerFunction(Ids::GlRenderbufferStorage, callGlRenderbufferStorage);
    interpreter->registerFunction(Ids::GlRenderbufferStorageMultisample,
                                  callGlRenderbufferStorageMultisample);
    interpreter->registerFunction(Ids::GlStencilMask, callGlStencilMask);
    interpreter->registerFunction(Ids::GlStencilMaskSeparate, callGlStencilMaskSeparate);
    interpreter->registerFunction(Ids::GlDisable, callGlDisable);
    interpreter->registerFunction(Ids::GlEnable, callGlEnable);
    interpreter->registerFunction(Ids::GlFinish, callGlFinish);
    interpreter->registerFunction(Ids::GlFlush, callGlFlush);
    interpreter->registerFunction(Ids::GlFlushMappedBufferRange, callGlFlushMappedBufferRange);
    interpreter->registerFunction(Ids::GlGetError, callGlGetError);
    interpreter->registerFunction(Ids::GlHint, callGlHint);
    interpreter->registerFunction(Ids::GlActiveShaderProgram, callGlActiveShaderProgram);
    interpreter->registerFunction(Ids::GlAttachShader, callGlAttachShader);
    interpreter->registerFunction(Ids::GlBindAttribLocation, callGlBindAttribLocation);
    interpreter->registerFunction(Ids::GlBindProgramPipeline, callGlBindProgramPipeline);
    interpreter->registerFunction(Ids::GlCompileShader, callGlCompileShader);
    interpreter->registerFunction(Ids::GlCreateProgram, callGlCreateProgram);
    interpreter->registerFunction(Ids::GlCreateShader, callGlCreateShader);
    interpreter->registerFunction(Ids::GlCreateShaderProgramv, callGlCreateShaderProgramv);
    interpreter->registerFunction(Ids::GlDeleteProgram, callGlDeleteProgram);
    interpreter->registerFunction(Ids::GlDeleteProgramPipelines, callGlDeleteProgramPipelines);
    interpreter->registerFunction(Ids::GlDeleteShader, callGlDeleteShader);
    interpreter->registerFunction(Ids::GlDetachShader, callGlDetachShader);
    interpreter->registerFunction(Ids::GlDispatchCompute, callGlDispatchCompute);
    interpreter->registerFunction(Ids::GlDispatchComputeIndirect, callGlDispatchComputeIndirect);
    interpreter->registerFunction(Ids::GlGenProgramPipelines, callGlGenProgramPipelines);
    interpreter->registerFunction(Ids::GlGetActiveAttrib, callGlGetActiveAttrib);
    interpreter->registerFunction(Ids::GlGetActiveUniform, callGlGetActiveUniform);
    interpreter->registerFunction(Ids::GlGetActiveUniformBlockName,
                                  callGlGetActiveUniformBlockName);
    interpreter->registerFunction(Ids::GlGetActiveUniformBlockiv, callGlGetActiveUniformBlockiv);
    interpreter->registerFunction(Ids::GlGetActiveUniformsiv, callGlGetActiveUniformsiv);
    interpreter->registerFunction(Ids::GlGetAttachedShaders, callGlGetAttachedShaders);
    interpreter->registerFunction(Ids::GlGetAttribLocation, callGlGetAttribLocation);
    interpreter->registerFunction(Ids::GlGetFragDataLocation, callGlGetFragDataLocation);
    interpreter->registerFunction(Ids::GlGetProgramBinary, callGlGetProgramBinary);
    interpreter->registerFunction(Ids::GlGetProgramInfoLog, callGlGetProgramInfoLog);
    interpreter->registerFunction(Ids::GlGetProgramInterfaceiv, callGlGetProgramInterfaceiv);
    interpreter->registerFunction(Ids::GlGetProgramPipelineInfoLog,
                                  callGlGetProgramPipelineInfoLog);
    interpreter->registerFunction(Ids::GlGetProgramPipelineiv, callGlGetProgramPipelineiv);
    interpreter->registerFunction(Ids::GlGetProgramResourceIndex, callGlGetProgramResourceIndex);
    interpreter->registerFunction(Ids::GlGetProgramResourceLocation,
                                  callGlGetProgramResourceLocation);
    interpreter->registerFunction(Ids::GlGetProgramResourceName, callGlGetProgramResourceName);
    interpreter->registerFunction(Ids::GlGetProgramResourceiv, callGlGetProgramResourceiv);
    interpreter->registerFunction(Ids::GlGetProgramiv, callGlGetProgramiv);
    interpreter->registerFunction(Ids::GlGetShaderInfoLog, callGlGetShaderInfoLog);
    interpreter->registerFunction(Ids::GlGetShaderPrecisionFormat, callGlGetShaderPrecisionFormat);
    interpreter->registerFunction(Ids::GlGetShaderSource, callGlGetShaderSource);
    interpreter->registerFunction(Ids::GlGetShaderiv, callGlGetShaderiv);
    interpreter->registerFunction(Ids::GlGetUniformBlockIndex, callGlGetUniformBlockIndex);
    interpreter->registerFunction(Ids::GlGetUniformIndices, callGlGetUniformIndices);
    interpreter->registerFunction(Ids::GlGetUniformLocation, callGlGetUniformLocation);
    interpreter->registerFunction(Ids::GlGetUniformfv, callGlGetUniformfv);
    interpreter->registerFunction(Ids::GlGetUniformiv, callGlGetUniformiv);
    interpreter->registerFunction(Ids::GlGetUniformuiv, callGlGetUniformuiv);
    interpreter->registerFunction(Ids::GlIsProgram, callGlIsProgram);
    interpreter->registerFunction(Ids::GlIsProgramPipeline, callGlIsProgramPipeline);
    interpreter->registerFunction(Ids::GlIsShader, callGlIsShader);
    interpreter->registerFunction(Ids::GlLinkProgram, callGlLinkProgram);
    interpreter->registerFunction(Ids::GlMemoryBarrier, callGlMemoryBarrier);
    interpreter->registerFunction(Ids::GlMemoryBarrierByRegion, callGlMemoryBarrierByRegion);
    interpreter->registerFunction(Ids::GlProgramBinary, callGlProgramBinary);
    interpreter->registerFunction(Ids::GlProgramParameteri, callGlProgramParameteri);
    interpreter->registerFunction(Ids::GlProgramUniform1f, callGlProgramUniform1f);
    interpreter->registerFunction(Ids::GlProgramUniform1fv, callGlProgramUniform1fv);
    interpreter->registerFunction(Ids::GlProgramUniform1i, callGlProgramUniform1i);
    interpreter->registerFunction(Ids::GlProgramUniform1iv, callGlProgramUniform1iv);
    interpreter->registerFunction(Ids::GlProgramUniform1ui, callGlProgramUniform1ui);
    interpreter->registerFunction(Ids::GlProgramUniform1uiv, callGlProgramUniform1uiv);
    interpreter->registerFunction(Ids::GlProgramUniform2f, callGlProgramUniform2f);
    interpreter->registerFunction(Ids::GlProgramUniform2fv, callGlProgramUniform2fv);
    interpreter->registerFunction(Ids::GlProgramUniform2i, callGlProgramUniform2i);
    interpreter->registerFunction(Ids::GlProgramUniform2iv, callGlProgramUniform2iv);
    interpreter->registerFunction(Ids::GlProgramUniform2ui, callGlProgramUniform2ui);
    interpreter->registerFunction(Ids::GlProgramUniform2uiv, callGlProgramUniform2uiv);
    interpreter->registerFunction(Ids::GlProgramUniform3f, callGlProgramUniform3f);
    interpreter->registerFunction(Ids::GlProgramUniform3fv, callGlProgramUniform3fv);
    interpreter->registerFunction(Ids::GlProgramUniform3i, callGlProgramUniform3i);
    interpreter->registerFunction(Ids::GlProgramUniform3iv, callGlProgramUniform3iv);
    interpreter->registerFunction(Ids::GlProgramUniform3ui, callGlProgramUniform3ui);
    interpreter->registerFunction(Ids::GlProgramUniform3uiv, callGlProgramUniform3uiv);
    interpreter->registerFunction(Ids::GlProgramUniform4f, callGlProgramUniform4f);
    interpreter->registerFunction(Ids::GlProgramUniform4fv, callGlProgramUniform4fv);
    interpreter->registerFunction(Ids::GlProgramUniform4i, callGlProgramUniform4i);
    interpreter->registerFunction(Ids::GlProgramUniform4iv, callGlProgramUniform4iv);
    interpreter->registerFunction(Ids::GlProgramUniform4ui, callGlProgramUniform4ui);
    interpreter->registerFunction(Ids::GlProgramUniform4uiv, callGlProgramUniform4uiv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix2fv, callGlProgramUniformMatrix2fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix2x3fv,
                                  callGlProgramUniformMatrix2x3fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix2x4fv,
                                  callGlProgramUniformMatrix2x4fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix3fv, callGlProgramUniformMatrix3fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix3x2fv,
                                  callGlProgramUniformMatrix3x2fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix3x4fv,
                                  callGlProgramUniformMatrix3x4fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix4fv, callGlProgramUniformMatrix4fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix4x2fv,
                                  callGlProgramUniformMatrix4x2fv);
    interpreter->registerFunction(Ids::GlProgramUniformMatrix4x3fv,
                                  callGlProgramUniformMatrix4x3fv);
    interpreter->registerFunction(Ids::GlReleaseShaderCompiler, callGlReleaseShaderCompiler);
    interpreter->registerFunction(Ids::GlShaderBinary, callGlShaderBinary);
    interpreter->registerFunction(Ids::GlShaderSource, callGlShaderSource);
    interpreter->registerFunction(Ids::GlUniform1f, callGlUniform1f);
    interpreter->registerFunction(Ids::GlUniform1fv, callGlUniform1fv);
    interpreter->registerFunction(Ids::GlUniform1i, callGlUniform1i);
    interpreter->registerFunction(Ids::GlUniform1iv, callGlUniform1iv);
    interpreter->registerFunction(Ids::GlUniform1ui, callGlUniform1ui);
    interpreter->registerFunction(Ids::GlUniform1uiv, callGlUniform1uiv);
    interpreter->registerFunction(Ids::GlUniform2f, callGlUniform2f);
    interpreter->registerFunction(Ids::GlUniform2fv, callGlUniform2fv);
    interpreter->registerFunction(Ids::GlUniform2i, callGlUniform2i);
    interpreter->registerFunction(Ids::GlUniform2iv, callGlUniform2iv);
    interpreter->registerFunction(Ids::GlUniform2ui, callGlUniform2ui);
    interpreter->registerFunction(Ids::GlUniform2uiv, callGlUniform2uiv);
    interpreter->registerFunction(Ids::GlUniform3f, callGlUniform3f);
    interpreter->registerFunction(Ids::GlUniform3fv, callGlUniform3fv);
    interpreter->registerFunction(Ids::GlUniform3i, callGlUniform3i);
    interpreter->registerFunction(Ids::GlUniform3iv, callGlUniform3iv);
    interpreter->registerFunction(Ids::GlUniform3ui, callGlUniform3ui);
    interpreter->registerFunction(Ids::GlUniform3uiv, callGlUniform3uiv);
    interpreter->registerFunction(Ids::GlUniform4f, callGlUniform4f);
    interpreter->registerFunction(Ids::GlUniform4fv, callGlUniform4fv);
    interpreter->registerFunction(Ids::GlUniform4i, callGlUniform4i);
    interpreter->registerFunction(Ids::GlUniform4iv, callGlUniform4iv);
    interpreter->registerFunction(Ids::GlUniform4ui, callGlUniform4ui);
    interpreter->registerFunction(Ids::GlUniform4uiv, callGlUniform4uiv);
    interpreter->registerFunction(Ids::GlUniformBlockBinding, callGlUniformBlockBinding);
    interpreter->registerFunction(Ids::GlUniformMatrix2fv, callGlUniformMatrix2fv);
    interpreter->registerFunction(Ids::GlUniformMatrix2x3fv, callGlUniformMatrix2x3fv);
    interpreter->registerFunction(Ids::GlUniformMatrix2x4fv, callGlUniformMatrix2x4fv);
    interpreter->registerFunction(Ids::GlUniformMatrix3fv, callGlUniformMatrix3fv);
    interpreter->registerFunction(Ids::GlUniformMatrix3x2fv, callGlUniformMatrix3x2fv);
    interpreter->registerFunction(Ids::GlUniformMatrix3x4fv, callGlUniformMatrix3x4fv);
    interpreter->registerFunction(Ids::GlUniformMatrix4fv, callGlUniformMatrix4fv);
    interpreter->registerFunction(Ids::GlUniformMatrix4x2fv, callGlUniformMatrix4x2fv);
    interpreter->registerFunction(Ids::GlUniformMatrix4x3fv, callGlUniformMatrix4x3fv);
    interpreter->registerFunction(Ids::GlUseProgram, callGlUseProgram);
    interpreter->registerFunction(Ids::GlUseProgramStages, callGlUseProgramStages);
    interpreter->registerFunction(Ids::GlValidateProgram, callGlValidateProgram);
    interpreter->registerFunction(Ids::GlValidateProgramPipeline, callGlValidateProgramPipeline);
    interpreter->registerFunction(Ids::GlCullFace, callGlCullFace);
    interpreter->registerFunction(Ids::GlDepthRangef, callGlDepthRangef);
    interpreter->registerFunction(Ids::GlFrontFace, callGlFrontFace);
    interpreter->registerFunction(Ids::GlGetMultisamplefv, callGlGetMultisamplefv);
    interpreter->registerFunction(Ids::GlLineWidth, callGlLineWidth);
    interpreter->registerFunction(Ids::GlPolygonOffset, callGlPolygonOffset);
    interpreter->registerFunction(Ids::GlViewport, callGlViewport);
    interpreter->registerFunction(Ids::GlGetBooleaniV, callGlGetBooleaniV);
    interpreter->registerFunction(Ids::GlGetBooleanv, callGlGetBooleanv);
    interpreter->registerFunction(Ids::GlGetFloatv, callGlGetFloatv);
    interpreter->registerFunction(Ids::GlGetInteger64iV, callGlGetInteger64iV);
    interpreter->registerFunction(Ids::GlGetInteger64v, callGlGetInteger64v);
    interpreter->registerFunction(Ids::GlGetIntegeriV, callGlGetIntegeriV);
    interpreter->registerFunction(Ids::GlGetIntegerv, callGlGetIntegerv);
    interpreter->registerFunction(Ids::GlGetInternalformativ, callGlGetInternalformativ);
    interpreter->registerFunction(Ids::GlGetString, callGlGetString);
    interpreter->registerFunction(Ids::GlGetStringi, callGlGetStringi);
    interpreter->registerFunction(Ids::GlIsEnabled, callGlIsEnabled);
    interpreter->registerFunction(Ids::GlClientWaitSync, callGlClientWaitSync);
    interpreter->registerFunction(Ids::GlDeleteSync, callGlDeleteSync);
    interpreter->registerFunction(Ids::GlFenceSync, callGlFenceSync);
    interpreter->registerFunction(Ids::GlGetSynciv, callGlGetSynciv);
    interpreter->registerFunction(Ids::GlIsSync, callGlIsSync);
    interpreter->registerFunction(Ids::GlWaitSync, callGlWaitSync);
    interpreter->registerFunction(Ids::GlActiveTexture, callGlActiveTexture);
    interpreter->registerFunction(Ids::GlBindImageTexture, callGlBindImageTexture);
    interpreter->registerFunction(Ids::GlBindSampler, callGlBindSampler);
    interpreter->registerFunction(Ids::GlBindTexture, callGlBindTexture);
    interpreter->registerFunction(Ids::GlCompressedTexImage2D, callGlCompressedTexImage2D);
    interpreter->registerFunction(Ids::GlCompressedTexImage3D, callGlCompressedTexImage3D);
    interpreter->registerFunction(Ids::GlCompressedTexSubImage2D, callGlCompressedTexSubImage2D);
    interpreter->registerFunction(Ids::GlCompressedTexSubImage3D, callGlCompressedTexSubImage3D);
    interpreter->registerFunction(Ids::GlCopyTexImage2D, callGlCopyTexImage2D);
    interpreter->registerFunction(Ids::GlCopyTexSubImage2D, callGlCopyTexSubImage2D);
    interpreter->registerFunction(Ids::GlCopyTexSubImage3D, callGlCopyTexSubImage3D);
    interpreter->registerFunction(Ids::GlDeleteSamplers, callGlDeleteSamplers);
    interpreter->registerFunction(Ids::GlDeleteTextures, callGlDeleteTextures);
    interpreter->registerFunction(Ids::GlGenSamplers, callGlGenSamplers);
    interpreter->registerFunction(Ids::GlGenTextures, callGlGenTextures);
    interpreter->registerFunction(Ids::GlGenerateMipmap, callGlGenerateMipmap);
    interpreter->registerFunction(Ids::GlGetSamplerParameterfv, callGlGetSamplerParameterfv);
    interpreter->registerFunction(Ids::GlGetSamplerParameteriv, callGlGetSamplerParameteriv);
    interpreter->registerFunction(Ids::GlGetTexLevelParameterfv, callGlGetTexLevelParameterfv);
    interpreter->registerFunction(Ids::GlGetTexLevelParameteriv, callGlGetTexLevelParameteriv);
    interpreter->registerFunction(Ids::GlGetTexParameterfv, callGlGetTexParameterfv);
    interpreter->registerFunction(Ids::GlGetTexParameteriv, callGlGetTexParameteriv);
    interpreter->registerFunction(Ids::GlIsSampler, callGlIsSampler);
    interpreter->registerFunction(Ids::GlIsTexture, callGlIsTexture);
    interpreter->registerFunction(Ids::GlPixelStorei, callGlPixelStorei);
    interpreter->registerFunction(Ids::GlSamplerParameterf, callGlSamplerParameterf);
    interpreter->registerFunction(Ids::GlSamplerParameterfv, callGlSamplerParameterfv);
    interpreter->registerFunction(Ids::GlSamplerParameteri, callGlSamplerParameteri);
    interpreter->registerFunction(Ids::GlSamplerParameteriv, callGlSamplerParameteriv);
    interpreter->registerFunction(Ids::GlTexImage2D, callGlTexImage2D);
    interpreter->registerFunction(Ids::GlTexImage3D, callGlTexImage3D);
    interpreter->registerFunction(Ids::GlTexParameterf, callGlTexParameterf);
    interpreter->registerFunction(Ids::GlTexParameterfv, callGlTexParameterfv);
    interpreter->registerFunction(Ids::GlTexParameteri, callGlTexParameteri);
    interpreter->registerFunction(Ids::GlTexParameteriv, callGlTexParameteriv);
    interpreter->registerFunction(Ids::GlTexStorage2D, callGlTexStorage2D);
    interpreter->registerFunction(Ids::GlTexStorage2DMultisample, callGlTexStorage2DMultisample);
    interpreter->registerFunction(Ids::GlTexStorage3D, callGlTexStorage3D);
    interpreter->registerFunction(Ids::GlTexSubImage2D, callGlTexSubImage2D);
    interpreter->registerFunction(Ids::GlTexSubImage3D, callGlTexSubImage3D);
    interpreter->registerFunction(Ids::GlBeginTransformFeedback, callGlBeginTransformFeedback);
    interpreter->registerFunction(Ids::GlBindTransformFeedback, callGlBindTransformFeedback);
    interpreter->registerFunction(Ids::GlDeleteTransformFeedbacks, callGlDeleteTransformFeedbacks);
    interpreter->registerFunction(Ids::GlEndTransformFeedback, callGlEndTransformFeedback);
    interpreter->registerFunction(Ids::GlGenTransformFeedbacks, callGlGenTransformFeedbacks);
    interpreter->registerFunction(Ids::GlGetTransformFeedbackVarying,
                                  callGlGetTransformFeedbackVarying);
    interpreter->registerFunction(Ids::GlIsTransformFeedback, callGlIsTransformFeedback);
    interpreter->registerFunction(Ids::GlPauseTransformFeedback, callGlPauseTransformFeedback);
    interpreter->registerFunction(Ids::GlResumeTransformFeedback, callGlResumeTransformFeedback);
    interpreter->registerFunction(Ids::GlTransformFeedbackVaryings,
                                  callGlTransformFeedbackVaryings);
    interpreter->registerFunction(Ids::GlBindVertexArray, callGlBindVertexArray);
    interpreter->registerFunction(Ids::GlBindVertexBuffer, callGlBindVertexBuffer);
    interpreter->registerFunction(Ids::GlDeleteVertexArrays, callGlDeleteVertexArrays);
    interpreter->registerFunction(Ids::GlDisableVertexAttribArray, callGlDisableVertexAttribArray);
    interpreter->registerFunction(Ids::GlEnableVertexAttribArray, callGlEnableVertexAttribArray);
    interpreter->registerFunction(Ids::GlGenVertexArrays, callGlGenVertexArrays);
    interpreter->registerFunction(Ids::GlGetVertexAttribIiv, callGlGetVertexAttribIiv);
    interpreter->registerFunction(Ids::GlGetVertexAttribIuiv, callGlGetVertexAttribIuiv);
    interpreter->registerFunction(Ids::GlGetVertexAttribPointerv, callGlGetVertexAttribPointerv);
    interpreter->registerFunction(Ids::GlGetVertexAttribfv, callGlGetVertexAttribfv);
    interpreter->registerFunction(Ids::GlGetVertexAttribiv, callGlGetVertexAttribiv);
    interpreter->registerFunction(Ids::GlIsVertexArray, callGlIsVertexArray);
    interpreter->registerFunction(Ids::GlVertexAttrib1f, callGlVertexAttrib1f);
    interpreter->registerFunction(Ids::GlVertexAttrib1fv, callGlVertexAttrib1fv);
    interpreter->registerFunction(Ids::GlVertexAttrib2f, callGlVertexAttrib2f);
    interpreter->registerFunction(Ids::GlVertexAttrib2fv, callGlVertexAttrib2fv);
    interpreter->registerFunction(Ids::GlVertexAttrib3f, callGlVertexAttrib3f);
    interpreter->registerFunction(Ids::GlVertexAttrib3fv, callGlVertexAttrib3fv);
    interpreter->registerFunction(Ids::GlVertexAttrib4f, callGlVertexAttrib4f);
    interpreter->registerFunction(Ids::GlVertexAttrib4fv, callGlVertexAttrib4fv);
    interpreter->registerFunction(Ids::GlVertexAttribBinding, callGlVertexAttribBinding);
    interpreter->registerFunction(Ids::GlVertexAttribDivisor, callGlVertexAttribDivisor);
    interpreter->registerFunction(Ids::GlVertexAttribFormat, callGlVertexAttribFormat);
    interpreter->registerFunction(Ids::GlVertexAttribI4i, callGlVertexAttribI4i);
    interpreter->registerFunction(Ids::GlVertexAttribI4iv, callGlVertexAttribI4iv);
    interpreter->registerFunction(Ids::GlVertexAttribI4ui, callGlVertexAttribI4ui);
    interpreter->registerFunction(Ids::GlVertexAttribI4uiv, callGlVertexAttribI4uiv);
    interpreter->registerFunction(Ids::GlVertexAttribIFormat, callGlVertexAttribIFormat);
    interpreter->registerFunction(Ids::GlVertexAttribIPointer, callGlVertexAttribIPointer);
    interpreter->registerFunction(Ids::GlVertexAttribPointer, callGlVertexAttribPointer);
    interpreter->registerFunction(Ids::GlVertexBindingDivisor, callGlVertexBindingDivisor);
    interpreter->registerFunction(Ids::EglInitialize, callEglInitialize);
    interpreter->registerFunction(Ids::EglCreateContext, callEglCreateContext);
    interpreter->registerFunction(Ids::EglMakeCurrent, callEglMakeCurrent);
    interpreter->registerFunction(Ids::EglSwapBuffers, callEglSwapBuffers);
    interpreter->registerFunction(Ids::EglQuerySurface, callEglQuerySurface);
    interpreter->registerFunction(Ids::GlXCreateContext, callGlXCreateContext);
    interpreter->registerFunction(Ids::GlXCreateNewContext, callGlXCreateNewContext);
    interpreter->registerFunction(Ids::GlXMakeContextCurrent, callGlXMakeContextCurrent);
    interpreter->registerFunction(Ids::GlXMakeCurrent, callGlXMakeCurrent);
    interpreter->registerFunction(Ids::GlXSwapBuffers, callGlXSwapBuffers);
    interpreter->registerFunction(Ids::GlXQueryDrawable, callGlXQueryDrawable);
    interpreter->registerFunction(Ids::WglCreateContext, callWglCreateContext);
    interpreter->registerFunction(Ids::WglCreateContextAttribsARB, callWglCreateContextAttribsARB);
    interpreter->registerFunction(Ids::WglMakeCurrent, callWglMakeCurrent);
    interpreter->registerFunction(Ids::WglSwapBuffers, callWglSwapBuffers);
    interpreter->registerFunction(Ids::CGLCreateContext, callCGLCreateContext);
    interpreter->registerFunction(Ids::CGLSetCurrentContext, callCGLSetCurrentContext);
    interpreter->registerFunction(Ids::CGLGetSurface, callCGLGetSurface);
    interpreter->registerFunction(Ids::CGSGetSurfaceBounds, callCGSGetSurfaceBounds);
    interpreter->registerFunction(Ids::CGLFlushDrawable, callCGLFlushDrawable);
    interpreter->registerFunction(Ids::GlGetQueryObjecti64v, callGlGetQueryObjecti64v);
    interpreter->registerFunction(Ids::GlGetQueryObjectui64v, callGlGetQueryObjectui64v);
}
void Initialize() {
    glBlendBarrierKHR = reinterpret_cast<PFNGLBLENDBARRIERKHR>(
            gapic::GetGfxProcAddress("glBlendBarrierKHR", false));
    glBlendEquationSeparateiEXT = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEIEXT>(
            gapic::GetGfxProcAddress("glBlendEquationSeparateiEXT", false));
    glBlendEquationiEXT = reinterpret_cast<PFNGLBLENDEQUATIONIEXT>(
            gapic::GetGfxProcAddress("glBlendEquationiEXT", false));
    glBlendFuncSeparateiEXT = reinterpret_cast<PFNGLBLENDFUNCSEPARATEIEXT>(
            gapic::GetGfxProcAddress("glBlendFuncSeparateiEXT", false));
    glBlendFunciEXT = reinterpret_cast<PFNGLBLENDFUNCIEXT>(
            gapic::GetGfxProcAddress("glBlendFunciEXT", false));
    glColorMaskiEXT = reinterpret_cast<PFNGLCOLORMASKIEXT>(
            gapic::GetGfxProcAddress("glColorMaskiEXT", false));
    glCopyImageSubDataEXT = reinterpret_cast<PFNGLCOPYIMAGESUBDATAEXT>(
            gapic::GetGfxProcAddress("glCopyImageSubDataEXT", false));
    glDebugMessageCallbackKHR = reinterpret_cast<PFNGLDEBUGMESSAGECALLBACKKHR>(
            gapic::GetGfxProcAddress("glDebugMessageCallbackKHR", false));
    glDebugMessageControlKHR = reinterpret_cast<PFNGLDEBUGMESSAGECONTROLKHR>(
            gapic::GetGfxProcAddress("glDebugMessageControlKHR", false));
    glDebugMessageInsertKHR = reinterpret_cast<PFNGLDEBUGMESSAGEINSERTKHR>(
            gapic::GetGfxProcAddress("glDebugMessageInsertKHR", false));
    glDisableiEXT =
            reinterpret_cast<PFNGLDISABLEIEXT>(gapic::GetGfxProcAddress("glDisableiEXT", false));
    glEnableiEXT =
            reinterpret_cast<PFNGLENABLEIEXT>(gapic::GetGfxProcAddress("glEnableiEXT", false));
    glFramebufferTextureEXT = reinterpret_cast<PFNGLFRAMEBUFFERTEXTUREEXT>(
            gapic::GetGfxProcAddress("glFramebufferTextureEXT", false));
    glGetDebugMessageLogKHR = reinterpret_cast<PFNGLGETDEBUGMESSAGELOGKHR>(
            gapic::GetGfxProcAddress("glGetDebugMessageLogKHR", false));
    glGetObjectLabelKHR = reinterpret_cast<PFNGLGETOBJECTLABELKHR>(
            gapic::GetGfxProcAddress("glGetObjectLabelKHR", false));
    glGetObjectPtrLabelKHR = reinterpret_cast<PFNGLGETOBJECTPTRLABELKHR>(
            gapic::GetGfxProcAddress("glGetObjectPtrLabelKHR", false));
    glGetPointervKHR = reinterpret_cast<PFNGLGETPOINTERVKHR>(
            gapic::GetGfxProcAddress("glGetPointervKHR", false));
    glGetSamplerParameterIivEXT = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIIVEXT>(
            gapic::GetGfxProcAddress("glGetSamplerParameterIivEXT", false));
    glGetSamplerParameterIuivEXT = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIUIVEXT>(
            gapic::GetGfxProcAddress("glGetSamplerParameterIuivEXT", false));
    glGetTexParameterIivEXT = reinterpret_cast<PFNGLGETTEXPARAMETERIIVEXT>(
            gapic::GetGfxProcAddress("glGetTexParameterIivEXT", false));
    glGetTexParameterIuivEXT = reinterpret_cast<PFNGLGETTEXPARAMETERIUIVEXT>(
            gapic::GetGfxProcAddress("glGetTexParameterIuivEXT", false));
    glIsEnablediEXT = reinterpret_cast<PFNGLISENABLEDIEXT>(
            gapic::GetGfxProcAddress("glIsEnablediEXT", false));
    glMinSampleShadingOES = reinterpret_cast<PFNGLMINSAMPLESHADINGOES>(
            gapic::GetGfxProcAddress("glMinSampleShadingOES", false));
    glObjectLabelKHR = reinterpret_cast<PFNGLOBJECTLABELKHR>(
            gapic::GetGfxProcAddress("glObjectLabelKHR", false));
    glObjectPtrLabelKHR = reinterpret_cast<PFNGLOBJECTPTRLABELKHR>(
            gapic::GetGfxProcAddress("glObjectPtrLabelKHR", false));
    glPatchParameteriEXT = reinterpret_cast<PFNGLPATCHPARAMETERIEXT>(
            gapic::GetGfxProcAddress("glPatchParameteriEXT", false));
    glPopDebugGroupKHR = reinterpret_cast<PFNGLPOPDEBUGGROUPKHR>(
            gapic::GetGfxProcAddress("glPopDebugGroupKHR", false));
    glPrimitiveBoundingBoxEXT = reinterpret_cast<PFNGLPRIMITIVEBOUNDINGBOXEXT>(
            gapic::GetGfxProcAddress("glPrimitiveBoundingBoxEXT", false));
    glPushDebugGroupKHR = reinterpret_cast<PFNGLPUSHDEBUGGROUPKHR>(
            gapic::GetGfxProcAddress("glPushDebugGroupKHR", false));
    glSamplerParameterIivEXT = reinterpret_cast<PFNGLSAMPLERPARAMETERIIVEXT>(
            gapic::GetGfxProcAddress("glSamplerParameterIivEXT", false));
    glSamplerParameterIuivEXT = reinterpret_cast<PFNGLSAMPLERPARAMETERIUIVEXT>(
            gapic::GetGfxProcAddress("glSamplerParameterIuivEXT", false));
    glTexBufferEXT =
            reinterpret_cast<PFNGLTEXBUFFEREXT>(gapic::GetGfxProcAddress("glTexBufferEXT", false));
    glTexBufferRangeEXT = reinterpret_cast<PFNGLTEXBUFFERRANGEEXT>(
            gapic::GetGfxProcAddress("glTexBufferRangeEXT", false));
    glTexParameterIivEXT = reinterpret_cast<PFNGLTEXPARAMETERIIVEXT>(
            gapic::GetGfxProcAddress("glTexParameterIivEXT", false));
    glTexParameterIuivEXT = reinterpret_cast<PFNGLTEXPARAMETERIUIVEXT>(
            gapic::GetGfxProcAddress("glTexParameterIuivEXT", false));
    glTexStorage3DMultisampleOES = reinterpret_cast<PFNGLTEXSTORAGE3DMULTISAMPLEOES>(
            gapic::GetGfxProcAddress("glTexStorage3DMultisampleOES", false));
    glBeginQuery =
            reinterpret_cast<PFNGLBEGINQUERY>(gapic::GetGfxProcAddress("glBeginQuery", false));
    glDeleteQueries = reinterpret_cast<PFNGLDELETEQUERIES>(
            gapic::GetGfxProcAddress("glDeleteQueries", false));
    glEndQuery = reinterpret_cast<PFNGLENDQUERY>(gapic::GetGfxProcAddress("glEndQuery", false));
    glGenQueries =
            reinterpret_cast<PFNGLGENQUERIES>(gapic::GetGfxProcAddress("glGenQueries", false));
    glGetQueryObjectuiv = reinterpret_cast<PFNGLGETQUERYOBJECTUIV>(
            gapic::GetGfxProcAddress("glGetQueryObjectuiv", false));
    glGetQueryiv =
            reinterpret_cast<PFNGLGETQUERYIV>(gapic::GetGfxProcAddress("glGetQueryiv", false));
    glIsQuery = reinterpret_cast<PFNGLISQUERY>(gapic::GetGfxProcAddress("glIsQuery", false));
    glBindBuffer =
            reinterpret_cast<PFNGLBINDBUFFER>(gapic::GetGfxProcAddress("glBindBuffer", false));
    glBindBufferBase = reinterpret_cast<PFNGLBINDBUFFERBASE>(
            gapic::GetGfxProcAddress("glBindBufferBase", false));
    glBindBufferRange = reinterpret_cast<PFNGLBINDBUFFERRANGE>(
            gapic::GetGfxProcAddress("glBindBufferRange", false));
    glBufferData =
            reinterpret_cast<PFNGLBUFFERDATA>(gapic::GetGfxProcAddress("glBufferData", false));
    glBufferSubData = reinterpret_cast<PFNGLBUFFERSUBDATA>(
            gapic::GetGfxProcAddress("glBufferSubData", false));
    glCopyBufferSubData = reinterpret_cast<PFNGLCOPYBUFFERSUBDATA>(
            gapic::GetGfxProcAddress("glCopyBufferSubData", false));
    glDeleteBuffers = reinterpret_cast<PFNGLDELETEBUFFERS>(
            gapic::GetGfxProcAddress("glDeleteBuffers", false));
    glGenBuffers =
            reinterpret_cast<PFNGLGENBUFFERS>(gapic::GetGfxProcAddress("glGenBuffers", false));
    glGetBufferParameteri64v = reinterpret_cast<PFNGLGETBUFFERPARAMETERI64V>(
            gapic::GetGfxProcAddress("glGetBufferParameteri64v", false));
    glGetBufferParameteriv = reinterpret_cast<PFNGLGETBUFFERPARAMETERIV>(
            gapic::GetGfxProcAddress("glGetBufferParameteriv", false));
    glGetBufferPointerv = reinterpret_cast<PFNGLGETBUFFERPOINTERV>(
            gapic::GetGfxProcAddress("glGetBufferPointerv", false));
    glIsBuffer = reinterpret_cast<PFNGLISBUFFER>(gapic::GetGfxProcAddress("glIsBuffer", false));
    glMapBufferRange = reinterpret_cast<PFNGLMAPBUFFERRANGE>(
            gapic::GetGfxProcAddress("glMapBufferRange", false));
    glUnmapBuffer =
            reinterpret_cast<PFNGLUNMAPBUFFER>(gapic::GetGfxProcAddress("glUnmapBuffer", false));
    glDrawArrays =
            reinterpret_cast<PFNGLDRAWARRAYS>(gapic::GetGfxProcAddress("glDrawArrays", false));
    glDrawArraysIndirect = reinterpret_cast<PFNGLDRAWARRAYSINDIRECT>(
            gapic::GetGfxProcAddress("glDrawArraysIndirect", false));
    glDrawArraysInstanced = reinterpret_cast<PFNGLDRAWARRAYSINSTANCED>(
            gapic::GetGfxProcAddress("glDrawArraysInstanced", false));
    glDrawBuffers =
            reinterpret_cast<PFNGLDRAWBUFFERS>(gapic::GetGfxProcAddress("glDrawBuffers", false));
    glDrawElements =
            reinterpret_cast<PFNGLDRAWELEMENTS>(gapic::GetGfxProcAddress("glDrawElements", false));
    glDrawElementsIndirect = reinterpret_cast<PFNGLDRAWELEMENTSINDIRECT>(
            gapic::GetGfxProcAddress("glDrawElementsIndirect", false));
    glDrawElementsInstanced = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCED>(
            gapic::GetGfxProcAddress("glDrawElementsInstanced", false));
    glDrawRangeElements = reinterpret_cast<PFNGLDRAWRANGEELEMENTS>(
            gapic::GetGfxProcAddress("glDrawRangeElements", false));
    glActiveShaderProgramEXT = reinterpret_cast<PFNGLACTIVESHADERPROGRAMEXT>(
            gapic::GetGfxProcAddress("glActiveShaderProgramEXT", false));
    glAlphaFuncQCOM = reinterpret_cast<PFNGLALPHAFUNCQCOM>(
            gapic::GetGfxProcAddress("glAlphaFuncQCOM", false));
    glBeginConditionalRenderNV = reinterpret_cast<PFNGLBEGINCONDITIONALRENDERNV>(
            gapic::GetGfxProcAddress("glBeginConditionalRenderNV", false));
    glBeginPerfMonitorAMD = reinterpret_cast<PFNGLBEGINPERFMONITORAMD>(
            gapic::GetGfxProcAddress("glBeginPerfMonitorAMD", false));
    glBeginPerfQueryINTEL = reinterpret_cast<PFNGLBEGINPERFQUERYINTEL>(
            gapic::GetGfxProcAddress("glBeginPerfQueryINTEL", false));
    glBeginQueryEXT = reinterpret_cast<PFNGLBEGINQUERYEXT>(
            gapic::GetGfxProcAddress("glBeginQueryEXT", false));
    glBindProgramPipelineEXT = reinterpret_cast<PFNGLBINDPROGRAMPIPELINEEXT>(
            gapic::GetGfxProcAddress("glBindProgramPipelineEXT", false));
    glBindVertexArrayOES = reinterpret_cast<PFNGLBINDVERTEXARRAYOES>(
            gapic::GetGfxProcAddress("glBindVertexArrayOES", false));
    glBlendBarrierNV = reinterpret_cast<PFNGLBLENDBARRIERNV>(
            gapic::GetGfxProcAddress("glBlendBarrierNV", false));
    glBlendEquationSeparateiOES = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATEIOES>(
            gapic::GetGfxProcAddress("glBlendEquationSeparateiOES", false));
    glBlendEquationiOES = reinterpret_cast<PFNGLBLENDEQUATIONIOES>(
            gapic::GetGfxProcAddress("glBlendEquationiOES", false));
    glBlendFuncSeparateiOES = reinterpret_cast<PFNGLBLENDFUNCSEPARATEIOES>(
            gapic::GetGfxProcAddress("glBlendFuncSeparateiOES", false));
    glBlendFunciOES = reinterpret_cast<PFNGLBLENDFUNCIOES>(
            gapic::GetGfxProcAddress("glBlendFunciOES", false));
    glBlendParameteriNV = reinterpret_cast<PFNGLBLENDPARAMETERINV>(
            gapic::GetGfxProcAddress("glBlendParameteriNV", false));
    glBlitFramebufferANGLE = reinterpret_cast<PFNGLBLITFRAMEBUFFERANGLE>(
            gapic::GetGfxProcAddress("glBlitFramebufferANGLE", false));
    glBlitFramebufferNV = reinterpret_cast<PFNGLBLITFRAMEBUFFERNV>(
            gapic::GetGfxProcAddress("glBlitFramebufferNV", false));
    glBufferStorageEXT = reinterpret_cast<PFNGLBUFFERSTORAGEEXT>(
            gapic::GetGfxProcAddress("glBufferStorageEXT", false));
    glClientWaitSyncAPPLE = reinterpret_cast<PFNGLCLIENTWAITSYNCAPPLE>(
            gapic::GetGfxProcAddress("glClientWaitSyncAPPLE", false));
    glColorMaskiOES = reinterpret_cast<PFNGLCOLORMASKIOES>(
            gapic::GetGfxProcAddress("glColorMaskiOES", false));
    glCompressedTexImage3DOES = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE3DOES>(
            gapic::GetGfxProcAddress("glCompressedTexImage3DOES", false));
    glCompressedTexSubImage3DOES = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE3DOES>(
            gapic::GetGfxProcAddress("glCompressedTexSubImage3DOES", false));
    glCopyBufferSubDataNV = reinterpret_cast<PFNGLCOPYBUFFERSUBDATANV>(
            gapic::GetGfxProcAddress("glCopyBufferSubDataNV", false));
    glCopyImageSubDataOES = reinterpret_cast<PFNGLCOPYIMAGESUBDATAOES>(
            gapic::GetGfxProcAddress("glCopyImageSubDataOES", false));
    glCopyPathNV =
            reinterpret_cast<PFNGLCOPYPATHNV>(gapic::GetGfxProcAddress("glCopyPathNV", false));
    glCopyTexSubImage3DOES = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE3DOES>(
            gapic::GetGfxProcAddress("glCopyTexSubImage3DOES", false));
    glCopyTextureLevelsAPPLE = reinterpret_cast<PFNGLCOPYTEXTURELEVELSAPPLE>(
            gapic::GetGfxProcAddress("glCopyTextureLevelsAPPLE", false));
    glCoverFillPathInstancedNV = reinterpret_cast<PFNGLCOVERFILLPATHINSTANCEDNV>(
            gapic::GetGfxProcAddress("glCoverFillPathInstancedNV", false));
    glCoverFillPathNV = reinterpret_cast<PFNGLCOVERFILLPATHNV>(
            gapic::GetGfxProcAddress("glCoverFillPathNV", false));
    glCoverStrokePathInstancedNV = reinterpret_cast<PFNGLCOVERSTROKEPATHINSTANCEDNV>(
            gapic::GetGfxProcAddress("glCoverStrokePathInstancedNV", false));
    glCoverStrokePathNV = reinterpret_cast<PFNGLCOVERSTROKEPATHNV>(
            gapic::GetGfxProcAddress("glCoverStrokePathNV", false));
    glCoverageMaskNV = reinterpret_cast<PFNGLCOVERAGEMASKNV>(
            gapic::GetGfxProcAddress("glCoverageMaskNV", false));
    glCoverageOperationNV = reinterpret_cast<PFNGLCOVERAGEOPERATIONNV>(
            gapic::GetGfxProcAddress("glCoverageOperationNV", false));
    glCreatePerfQueryINTEL = reinterpret_cast<PFNGLCREATEPERFQUERYINTEL>(
            gapic::GetGfxProcAddress("glCreatePerfQueryINTEL", false));
    glCreateShaderProgramvEXT = reinterpret_cast<PFNGLCREATESHADERPROGRAMVEXT>(
            gapic::GetGfxProcAddress("glCreateShaderProgramvEXT", false));
    glDeleteFencesNV = reinterpret_cast<PFNGLDELETEFENCESNV>(
            gapic::GetGfxProcAddress("glDeleteFencesNV", false));
    glDeletePathsNV = reinterpret_cast<PFNGLDELETEPATHSNV>(
            gapic::GetGfxProcAddress("glDeletePathsNV", false));
    glDeletePerfMonitorsAMD = reinterpret_cast<PFNGLDELETEPERFMONITORSAMD>(
            gapic::GetGfxProcAddress("glDeletePerfMonitorsAMD", false));
    glDeletePerfQueryINTEL = reinterpret_cast<PFNGLDELETEPERFQUERYINTEL>(
            gapic::GetGfxProcAddress("glDeletePerfQueryINTEL", false));
    glDeleteProgramPipelinesEXT = reinterpret_cast<PFNGLDELETEPROGRAMPIPELINESEXT>(
            gapic::GetGfxProcAddress("glDeleteProgramPipelinesEXT", false));
    glDeleteQueriesEXT = reinterpret_cast<PFNGLDELETEQUERIESEXT>(
            gapic::GetGfxProcAddress("glDeleteQueriesEXT", false));
    glDeleteSyncAPPLE = reinterpret_cast<PFNGLDELETESYNCAPPLE>(
            gapic::GetGfxProcAddress("glDeleteSyncAPPLE", false));
    glDeleteVertexArraysOES = reinterpret_cast<PFNGLDELETEVERTEXARRAYSOES>(
            gapic::GetGfxProcAddress("glDeleteVertexArraysOES", false));
    glDepthRangeArrayfvNV = reinterpret_cast<PFNGLDEPTHRANGEARRAYFVNV>(
            gapic::GetGfxProcAddress("glDepthRangeArrayfvNV", false));
    glDepthRangeIndexedfNV = reinterpret_cast<PFNGLDEPTHRANGEINDEXEDFNV>(
            gapic::GetGfxProcAddress("glDepthRangeIndexedfNV", false));
    glDisableDriverControlQCOM = reinterpret_cast<PFNGLDISABLEDRIVERCONTROLQCOM>(
            gapic::GetGfxProcAddress("glDisableDriverControlQCOM", false));
    glDisableiNV =
            reinterpret_cast<PFNGLDISABLEINV>(gapic::GetGfxProcAddress("glDisableiNV", false));
    glDisableiOES =
            reinterpret_cast<PFNGLDISABLEIOES>(gapic::GetGfxProcAddress("glDisableiOES", false));
    glDiscardFramebufferEXT = reinterpret_cast<PFNGLDISCARDFRAMEBUFFEREXT>(
            gapic::GetGfxProcAddress("glDiscardFramebufferEXT", false));
    glDrawArraysInstancedANGLE = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDANGLE>(
            gapic::GetGfxProcAddress("glDrawArraysInstancedANGLE", false));
    glDrawArraysInstancedBaseInstanceEXT =
            reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXT>(
                    gapic::GetGfxProcAddress("glDrawArraysInstancedBaseInstanceEXT", false));
    glDrawArraysInstancedEXT = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDEXT>(
            gapic::GetGfxProcAddress("glDrawArraysInstancedEXT", false));
    glDrawArraysInstancedNV = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDNV>(
            gapic::GetGfxProcAddress("glDrawArraysInstancedNV", false));
    glDrawBuffersEXT = reinterpret_cast<PFNGLDRAWBUFFERSEXT>(
            gapic::GetGfxProcAddress("glDrawBuffersEXT", false));
    glDrawBuffersIndexedEXT = reinterpret_cast<PFNGLDRAWBUFFERSINDEXEDEXT>(
            gapic::GetGfxProcAddress("glDrawBuffersIndexedEXT", false));
    glDrawBuffersNV = reinterpret_cast<PFNGLDRAWBUFFERSNV>(
            gapic::GetGfxProcAddress("glDrawBuffersNV", false));
    glDrawElementsBaseVertexEXT = reinterpret_cast<PFNGLDRAWELEMENTSBASEVERTEXEXT>(
            gapic::GetGfxProcAddress("glDrawElementsBaseVertexEXT", false));
    glDrawElementsBaseVertexOES = reinterpret_cast<PFNGLDRAWELEMENTSBASEVERTEXOES>(
            gapic::GetGfxProcAddress("glDrawElementsBaseVertexOES", false));
    glDrawElementsInstancedANGLE = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDANGLE>(
            gapic::GetGfxProcAddress("glDrawElementsInstancedANGLE", false));
    glDrawElementsInstancedBaseInstanceEXT =
            reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXT>(
                    gapic::GetGfxProcAddress("glDrawElementsInstancedBaseInstanceEXT", false));
    glDrawElementsInstancedBaseVertexEXT =
            reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXT>(
                    gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertexEXT", false));
    glDrawElementsInstancedBaseVertexOES =
            reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXOES>(
                    gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertexOES", false));
    glDrawElementsInstancedBaseVertexBaseInstanceEXT =
            reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXT>(
                    gapic::GetGfxProcAddress("glDrawElementsInstancedBaseVertexBaseInstanceEXT",
                                             false));
    glDrawElementsInstancedEXT = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDEXT>(
            gapic::GetGfxProcAddress("glDrawElementsInstancedEXT", false));
    glDrawElementsInstancedNV = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDNV>(
            gapic::GetGfxProcAddress("glDrawElementsInstancedNV", false));
    glDrawRangeElementsBaseVertexEXT = reinterpret_cast<PFNGLDRAWRANGEELEMENTSBASEVERTEXEXT>(
            gapic::GetGfxProcAddress("glDrawRangeElementsBaseVertexEXT", false));
    glDrawRangeElementsBaseVertexOES = reinterpret_cast<PFNGLDRAWRANGEELEMENTSBASEVERTEXOES>(
            gapic::GetGfxProcAddress("glDrawRangeElementsBaseVertexOES", false));
    glEGLImageTargetRenderbufferStorageOES =
            reinterpret_cast<PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOES>(
                    gapic::GetGfxProcAddress("glEGLImageTargetRenderbufferStorageOES", false));
    glEGLImageTargetTexture2DOES = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOES>(
            gapic::GetGfxProcAddress("glEGLImageTargetTexture2DOES", false));
    glEnableDriverControlQCOM = reinterpret_cast<PFNGLENABLEDRIVERCONTROLQCOM>(
            gapic::GetGfxProcAddress("glEnableDriverControlQCOM", false));
    glEnableiNV = reinterpret_cast<PFNGLENABLEINV>(gapic::GetGfxProcAddress("glEnableiNV", false));
    glEnableiOES =
            reinterpret_cast<PFNGLENABLEIOES>(gapic::GetGfxProcAddress("glEnableiOES", false));
    glEndConditionalRenderNV = reinterpret_cast<PFNGLENDCONDITIONALRENDERNV>(
            gapic::GetGfxProcAddress("glEndConditionalRenderNV", false));
    glEndPerfMonitorAMD = reinterpret_cast<PFNGLENDPERFMONITORAMD>(
            gapic::GetGfxProcAddress("glEndPerfMonitorAMD", false));
    glEndPerfQueryINTEL = reinterpret_cast<PFNGLENDPERFQUERYINTEL>(
            gapic::GetGfxProcAddress("glEndPerfQueryINTEL", false));
    glEndQueryEXT =
            reinterpret_cast<PFNGLENDQUERYEXT>(gapic::GetGfxProcAddress("glEndQueryEXT", false));
    glEndTilingQCOM = reinterpret_cast<PFNGLENDTILINGQCOM>(
            gapic::GetGfxProcAddress("glEndTilingQCOM", false));
    glExtGetBufferPointervQCOM = reinterpret_cast<PFNGLEXTGETBUFFERPOINTERVQCOM>(
            gapic::GetGfxProcAddress("glExtGetBufferPointervQCOM", false));
    glExtGetBuffersQCOM = reinterpret_cast<PFNGLEXTGETBUFFERSQCOM>(
            gapic::GetGfxProcAddress("glExtGetBuffersQCOM", false));
    glExtGetFramebuffersQCOM = reinterpret_cast<PFNGLEXTGETFRAMEBUFFERSQCOM>(
            gapic::GetGfxProcAddress("glExtGetFramebuffersQCOM", false));
    glExtGetProgramBinarySourceQCOM = reinterpret_cast<PFNGLEXTGETPROGRAMBINARYSOURCEQCOM>(
            gapic::GetGfxProcAddress("glExtGetProgramBinarySourceQCOM", false));
    glExtGetProgramsQCOM = reinterpret_cast<PFNGLEXTGETPROGRAMSQCOM>(
            gapic::GetGfxProcAddress("glExtGetProgramsQCOM", false));
    glExtGetRenderbuffersQCOM = reinterpret_cast<PFNGLEXTGETRENDERBUFFERSQCOM>(
            gapic::GetGfxProcAddress("glExtGetRenderbuffersQCOM", false));
    glExtGetShadersQCOM = reinterpret_cast<PFNGLEXTGETSHADERSQCOM>(
            gapic::GetGfxProcAddress("glExtGetShadersQCOM", false));
    glExtGetTexLevelParameterivQCOM = reinterpret_cast<PFNGLEXTGETTEXLEVELPARAMETERIVQCOM>(
            gapic::GetGfxProcAddress("glExtGetTexLevelParameterivQCOM", false));
    glExtGetTexSubImageQCOM = reinterpret_cast<PFNGLEXTGETTEXSUBIMAGEQCOM>(
            gapic::GetGfxProcAddress("glExtGetTexSubImageQCOM", false));
    glExtGetTexturesQCOM = reinterpret_cast<PFNGLEXTGETTEXTURESQCOM>(
            gapic::GetGfxProcAddress("glExtGetTexturesQCOM", false));
    glExtIsProgramBinaryQCOM = reinterpret_cast<PFNGLEXTISPROGRAMBINARYQCOM>(
            gapic::GetGfxProcAddress("glExtIsProgramBinaryQCOM", false));
    glExtTexObjectStateOverrideiQCOM = reinterpret_cast<PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOM>(
            gapic::GetGfxProcAddress("glExtTexObjectStateOverrideiQCOM", false));
    glFenceSyncAPPLE = reinterpret_cast<PFNGLFENCESYNCAPPLE>(
            gapic::GetGfxProcAddress("glFenceSyncAPPLE", false));
    glFinishFenceNV = reinterpret_cast<PFNGLFINISHFENCENV>(
            gapic::GetGfxProcAddress("glFinishFenceNV", false));
    glFlushMappedBufferRangeEXT = reinterpret_cast<PFNGLFLUSHMAPPEDBUFFERRANGEEXT>(
            gapic::GetGfxProcAddress("glFlushMappedBufferRangeEXT", false));
    glFramebufferTexture2DMultisampleEXT =
            reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXT>(
                    gapic::GetGfxProcAddress("glFramebufferTexture2DMultisampleEXT", false));
    glFramebufferTexture2DMultisampleIMG =
            reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG>(
                    gapic::GetGfxProcAddress("glFramebufferTexture2DMultisampleIMG", false));
    glFramebufferTexture3DOES = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE3DOES>(
            gapic::GetGfxProcAddress("glFramebufferTexture3DOES", false));
    glFramebufferTextureOES = reinterpret_cast<PFNGLFRAMEBUFFERTEXTUREOES>(
            gapic::GetGfxProcAddress("glFramebufferTextureOES", false));
    glFramebufferTextureMultiviewOVR = reinterpret_cast<PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVR>(
            gapic::GetGfxProcAddress("glFramebufferTextureMultiviewOVR", false));
    glGenFencesNV =
            reinterpret_cast<PFNGLGENFENCESNV>(gapic::GetGfxProcAddress("glGenFencesNV", false));
    glGenPathsNV =
            reinterpret_cast<PFNGLGENPATHSNV>(gapic::GetGfxProcAddress("glGenPathsNV", false));
    glGenPerfMonitorsAMD = reinterpret_cast<PFNGLGENPERFMONITORSAMD>(
            gapic::GetGfxProcAddress("glGenPerfMonitorsAMD", false));
    glGenProgramPipelinesEXT = reinterpret_cast<PFNGLGENPROGRAMPIPELINESEXT>(
            gapic::GetGfxProcAddress("glGenProgramPipelinesEXT", false));
    glGenQueriesEXT = reinterpret_cast<PFNGLGENQUERIESEXT>(
            gapic::GetGfxProcAddress("glGenQueriesEXT", false));
    glGenVertexArraysOES = reinterpret_cast<PFNGLGENVERTEXARRAYSOES>(
            gapic::GetGfxProcAddress("glGenVertexArraysOES", false));
    glGetBufferPointervOES = reinterpret_cast<PFNGLGETBUFFERPOINTERVOES>(
            gapic::GetGfxProcAddress("glGetBufferPointervOES", false));
    glGetDriverControlStringQCOM = reinterpret_cast<PFNGLGETDRIVERCONTROLSTRINGQCOM>(
            gapic::GetGfxProcAddress("glGetDriverControlStringQCOM", false));
    glGetDriverControlsQCOM = reinterpret_cast<PFNGLGETDRIVERCONTROLSQCOM>(
            gapic::GetGfxProcAddress("glGetDriverControlsQCOM", false));
    glGetFenceivNV =
            reinterpret_cast<PFNGLGETFENCEIVNV>(gapic::GetGfxProcAddress("glGetFenceivNV", false));
    glGetFirstPerfQueryIdINTEL = reinterpret_cast<PFNGLGETFIRSTPERFQUERYIDINTEL>(
            gapic::GetGfxProcAddress("glGetFirstPerfQueryIdINTEL", false));
    glGetFloati_vNV = reinterpret_cast<PFNGLGETFLOATI_VNV>(
            gapic::GetGfxProcAddress("glGetFloati_vNV", false));
    glGetGraphicsResetStatusEXT = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXT>(
            gapic::GetGfxProcAddress("glGetGraphicsResetStatusEXT", false));
    glGetGraphicsResetStatusKHR = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSKHR>(
            gapic::GetGfxProcAddress("glGetGraphicsResetStatusKHR", false));
    glGetImageHandleNV = reinterpret_cast<PFNGLGETIMAGEHANDLENV>(
            gapic::GetGfxProcAddress("glGetImageHandleNV", false));
    glGetInteger64vAPPLE = reinterpret_cast<PFNGLGETINTEGER64VAPPLE>(
            gapic::GetGfxProcAddress("glGetInteger64vAPPLE", false));
    glGetIntegeri_vEXT = reinterpret_cast<PFNGLGETINTEGERI_VEXT>(
            gapic::GetGfxProcAddress("glGetIntegeri_vEXT", false));
    glGetInternalformatSampleivNV = reinterpret_cast<PFNGLGETINTERNALFORMATSAMPLEIVNV>(
            gapic::GetGfxProcAddress("glGetInternalformatSampleivNV", false));
    glGetNextPerfQueryIdINTEL = reinterpret_cast<PFNGLGETNEXTPERFQUERYIDINTEL>(
            gapic::GetGfxProcAddress("glGetNextPerfQueryIdINTEL", false));
    glGetObjectLabelEXT = reinterpret_cast<PFNGLGETOBJECTLABELEXT>(
            gapic::GetGfxProcAddress("glGetObjectLabelEXT", false));
    glGetPathCommandsNV = reinterpret_cast<PFNGLGETPATHCOMMANDSNV>(
            gapic::GetGfxProcAddress("glGetPathCommandsNV", false));
    glGetPathCoordsNV = reinterpret_cast<PFNGLGETPATHCOORDSNV>(
            gapic::GetGfxProcAddress("glGetPathCoordsNV", false));
    glGetPathDashArrayNV = reinterpret_cast<PFNGLGETPATHDASHARRAYNV>(
            gapic::GetGfxProcAddress("glGetPathDashArrayNV", false));
    glGetPathLengthNV = reinterpret_cast<PFNGLGETPATHLENGTHNV>(
            gapic::GetGfxProcAddress("glGetPathLengthNV", false));
    glGetPathMetricRangeNV = reinterpret_cast<PFNGLGETPATHMETRICRANGENV>(
            gapic::GetGfxProcAddress("glGetPathMetricRangeNV", false));
    glGetPathMetricsNV = reinterpret_cast<PFNGLGETPATHMETRICSNV>(
            gapic::GetGfxProcAddress("glGetPathMetricsNV", false));
    glGetPathParameterfvNV = reinterpret_cast<PFNGLGETPATHPARAMETERFVNV>(
            gapic::GetGfxProcAddress("glGetPathParameterfvNV", false));
    glGetPathParameterivNV = reinterpret_cast<PFNGLGETPATHPARAMETERIVNV>(
            gapic::GetGfxProcAddress("glGetPathParameterivNV", false));
    glGetPathSpacingNV = reinterpret_cast<PFNGLGETPATHSPACINGNV>(
            gapic::GetGfxProcAddress("glGetPathSpacingNV", false));
    glGetPerfCounterInfoINTEL = reinterpret_cast<PFNGLGETPERFCOUNTERINFOINTEL>(
            gapic::GetGfxProcAddress("glGetPerfCounterInfoINTEL", false));
    glGetPerfMonitorCounterDataAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERDATAAMD>(
            gapic::GetGfxProcAddress("glGetPerfMonitorCounterDataAMD", false));
    glGetPerfMonitorCounterInfoAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERINFOAMD>(
            gapic::GetGfxProcAddress("glGetPerfMonitorCounterInfoAMD", false));
    glGetPerfMonitorCounterStringAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERSTRINGAMD>(
            gapic::GetGfxProcAddress("glGetPerfMonitorCounterStringAMD", false));
    glGetPerfMonitorCountersAMD = reinterpret_cast<PFNGLGETPERFMONITORCOUNTERSAMD>(
            gapic::GetGfxProcAddress("glGetPerfMonitorCountersAMD", false));
    glGetPerfMonitorGroupStringAMD = reinterpret_cast<PFNGLGETPERFMONITORGROUPSTRINGAMD>(
            gapic::GetGfxProcAddress("glGetPerfMonitorGroupStringAMD", false));
    glGetPerfMonitorGroupsAMD = reinterpret_cast<PFNGLGETPERFMONITORGROUPSAMD>(
            gapic::GetGfxProcAddress("glGetPerfMonitorGroupsAMD", false));
    glGetPerfQueryDataINTEL = reinterpret_cast<PFNGLGETPERFQUERYDATAINTEL>(
            gapic::GetGfxProcAddress("glGetPerfQueryDataINTEL", false));
    glGetPerfQueryIdByNameINTEL = reinterpret_cast<PFNGLGETPERFQUERYIDBYNAMEINTEL>(
            gapic::GetGfxProcAddress("glGetPerfQueryIdByNameINTEL", false));
    glGetPerfQueryInfoINTEL = reinterpret_cast<PFNGLGETPERFQUERYINFOINTEL>(
            gapic::GetGfxProcAddress("glGetPerfQueryInfoINTEL", false));
    glGetProgramBinaryOES = reinterpret_cast<PFNGLGETPROGRAMBINARYOES>(
            gapic::GetGfxProcAddress("glGetProgramBinaryOES", false));
    glGetProgramPipelineInfoLogEXT = reinterpret_cast<PFNGLGETPROGRAMPIPELINEINFOLOGEXT>(
            gapic::GetGfxProcAddress("glGetProgramPipelineInfoLogEXT", false));
    glGetProgramPipelineivEXT = reinterpret_cast<PFNGLGETPROGRAMPIPELINEIVEXT>(
            gapic::GetGfxProcAddress("glGetProgramPipelineivEXT", false));
    glGetProgramResourcefvNV = reinterpret_cast<PFNGLGETPROGRAMRESOURCEFVNV>(
            gapic::GetGfxProcAddress("glGetProgramResourcefvNV", false));
    glGetQueryObjecti64vEXT = reinterpret_cast<PFNGLGETQUERYOBJECTI64VEXT>(
            gapic::GetGfxProcAddress("glGetQueryObjecti64vEXT", false));
    glGetQueryObjectivEXT = reinterpret_cast<PFNGLGETQUERYOBJECTIVEXT>(
            gapic::GetGfxProcAddress("glGetQueryObjectivEXT", false));
    glGetQueryObjectui64vEXT = reinterpret_cast<PFNGLGETQUERYOBJECTUI64VEXT>(
            gapic::GetGfxProcAddress("glGetQueryObjectui64vEXT", false));
    glGetQueryObjectuivEXT = reinterpret_cast<PFNGLGETQUERYOBJECTUIVEXT>(
            gapic::GetGfxProcAddress("glGetQueryObjectuivEXT", false));
    glGetQueryivEXT = reinterpret_cast<PFNGLGETQUERYIVEXT>(
            gapic::GetGfxProcAddress("glGetQueryivEXT", false));
    glGetSamplerParameterIivOES = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIIVOES>(
            gapic::GetGfxProcAddress("glGetSamplerParameterIivOES", false));
    glGetSamplerParameterIuivOES = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIUIVOES>(
            gapic::GetGfxProcAddress("glGetSamplerParameterIuivOES", false));
    glGetSyncivAPPLE = reinterpret_cast<PFNGLGETSYNCIVAPPLE>(
            gapic::GetGfxProcAddress("glGetSyncivAPPLE", false));
    glGetTexParameterIivOES = reinterpret_cast<PFNGLGETTEXPARAMETERIIVOES>(
            gapic::GetGfxProcAddress("glGetTexParameterIivOES", false));
    glGetTexParameterIuivOES = reinterpret_cast<PFNGLGETTEXPARAMETERIUIVOES>(
            gapic::GetGfxProcAddress("glGetTexParameterIuivOES", false));
    glGetTextureHandleNV = reinterpret_cast<PFNGLGETTEXTUREHANDLENV>(
            gapic::GetGfxProcAddress("glGetTextureHandleNV", false));
    glGetTextureSamplerHandleNV = reinterpret_cast<PFNGLGETTEXTURESAMPLERHANDLENV>(
            gapic::GetGfxProcAddress("glGetTextureSamplerHandleNV", false));
    glGetTranslatedShaderSourceANGLE = reinterpret_cast<PFNGLGETTRANSLATEDSHADERSOURCEANGLE>(
            gapic::GetGfxProcAddress("glGetTranslatedShaderSourceANGLE", false));
    glGetnUniformfvEXT = reinterpret_cast<PFNGLGETNUNIFORMFVEXT>(
            gapic::GetGfxProcAddress("glGetnUniformfvEXT", false));
    glGetnUniformfvKHR = reinterpret_cast<PFNGLGETNUNIFORMFVKHR>(
            gapic::GetGfxProcAddress("glGetnUniformfvKHR", false));
    glGetnUniformivEXT = reinterpret_cast<PFNGLGETNUNIFORMIVEXT>(
            gapic::GetGfxProcAddress("glGetnUniformivEXT", false));
    glGetnUniformivKHR = reinterpret_cast<PFNGLGETNUNIFORMIVKHR>(
            gapic::GetGfxProcAddress("glGetnUniformivKHR", false));
    glGetnUniformuivKHR = reinterpret_cast<PFNGLGETNUNIFORMUIVKHR>(
            gapic::GetGfxProcAddress("glGetnUniformuivKHR", false));
    glInsertEventMarkerEXT = reinterpret_cast<PFNGLINSERTEVENTMARKEREXT>(
            gapic::GetGfxProcAddress("glInsertEventMarkerEXT", false));
    glInterpolatePathsNV = reinterpret_cast<PFNGLINTERPOLATEPATHSNV>(
            gapic::GetGfxProcAddress("glInterpolatePathsNV", false));
    glIsEnablediOES = reinterpret_cast<PFNGLISENABLEDIOES>(
            gapic::GetGfxProcAddress("glIsEnablediOES", false));
    glIsEnablediNV =
            reinterpret_cast<PFNGLISENABLEDINV>(gapic::GetGfxProcAddress("glIsEnablediNV", false));
    glIsFenceNV = reinterpret_cast<PFNGLISFENCENV>(gapic::GetGfxProcAddress("glIsFenceNV", false));
    glIsImageHandleResidentNV = reinterpret_cast<PFNGLISIMAGEHANDLERESIDENTNV>(
            gapic::GetGfxProcAddress("glIsImageHandleResidentNV", false));
    glIsPathNV = reinterpret_cast<PFNGLISPATHNV>(gapic::GetGfxProcAddress("glIsPathNV", false));
    glIsPointInFillPathNV = reinterpret_cast<PFNGLISPOINTINFILLPATHNV>(
            gapic::GetGfxProcAddress("glIsPointInFillPathNV", false));
    glIsPointInStrokePathNV = reinterpret_cast<PFNGLISPOINTINSTROKEPATHNV>(
            gapic::GetGfxProcAddress("glIsPointInStrokePathNV", false));
    glIsProgramPipelineEXT = reinterpret_cast<PFNGLISPROGRAMPIPELINEEXT>(
            gapic::GetGfxProcAddress("glIsProgramPipelineEXT", false));
    glIsQueryEXT =
            reinterpret_cast<PFNGLISQUERYEXT>(gapic::GetGfxProcAddress("glIsQueryEXT", false));
    glIsSyncAPPLE =
            reinterpret_cast<PFNGLISSYNCAPPLE>(gapic::GetGfxProcAddress("glIsSyncAPPLE", false));
    glIsTextureHandleResidentNV = reinterpret_cast<PFNGLISTEXTUREHANDLERESIDENTNV>(
            gapic::GetGfxProcAddress("glIsTextureHandleResidentNV", false));
    glIsVertexArrayOES = reinterpret_cast<PFNGLISVERTEXARRAYOES>(
            gapic::GetGfxProcAddress("glIsVertexArrayOES", false));
    glLabelObjectEXT = reinterpret_cast<PFNGLLABELOBJECTEXT>(
            gapic::GetGfxProcAddress("glLabelObjectEXT", false));
    glMakeImageHandleNonResidentNV = reinterpret_cast<PFNGLMAKEIMAGEHANDLENONRESIDENTNV>(
            gapic::GetGfxProcAddress("glMakeImageHandleNonResidentNV", false));
    glMakeImageHandleResidentNV = reinterpret_cast<PFNGLMAKEIMAGEHANDLERESIDENTNV>(
            gapic::GetGfxProcAddress("glMakeImageHandleResidentNV", false));
    glMakeTextureHandleNonResidentNV = reinterpret_cast<PFNGLMAKETEXTUREHANDLENONRESIDENTNV>(
            gapic::GetGfxProcAddress("glMakeTextureHandleNonResidentNV", false));
    glMakeTextureHandleResidentNV = reinterpret_cast<PFNGLMAKETEXTUREHANDLERESIDENTNV>(
            gapic::GetGfxProcAddress("glMakeTextureHandleResidentNV", false));
    glMapBufferOES =
            reinterpret_cast<PFNGLMAPBUFFEROES>(gapic::GetGfxProcAddress("glMapBufferOES", false));
    glMapBufferRangeEXT = reinterpret_cast<PFNGLMAPBUFFERRANGEEXT>(
            gapic::GetGfxProcAddress("glMapBufferRangeEXT", false));
    glMatrixLoad3x2fNV = reinterpret_cast<PFNGLMATRIXLOAD3X2FNV>(
            gapic::GetGfxProcAddress("glMatrixLoad3x2fNV", false));
    glMatrixLoad3x3fNV = reinterpret_cast<PFNGLMATRIXLOAD3X3FNV>(
            gapic::GetGfxProcAddress("glMatrixLoad3x3fNV", false));
    glMatrixLoadTranspose3x3fNV = reinterpret_cast<PFNGLMATRIXLOADTRANSPOSE3X3FNV>(
            gapic::GetGfxProcAddress("glMatrixLoadTranspose3x3fNV", false));
    glMatrixMult3x2fNV = reinterpret_cast<PFNGLMATRIXMULT3X2FNV>(
            gapic::GetGfxProcAddress("glMatrixMult3x2fNV", false));
    glMatrixMult3x3fNV = reinterpret_cast<PFNGLMATRIXMULT3X3FNV>(
            gapic::GetGfxProcAddress("glMatrixMult3x3fNV", false));
    glMatrixMultTranspose3x3fNV = reinterpret_cast<PFNGLMATRIXMULTTRANSPOSE3X3FNV>(
            gapic::GetGfxProcAddress("glMatrixMultTranspose3x3fNV", false));
    glMultiDrawArraysEXT = reinterpret_cast<PFNGLMULTIDRAWARRAYSEXT>(
            gapic::GetGfxProcAddress("glMultiDrawArraysEXT", false));
    glMultiDrawArraysIndirectEXT = reinterpret_cast<PFNGLMULTIDRAWARRAYSINDIRECTEXT>(
            gapic::GetGfxProcAddress("glMultiDrawArraysIndirectEXT", false));
    glMultiDrawElementsBaseVertexEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSBASEVERTEXEXT>(
            gapic::GetGfxProcAddress("glMultiDrawElementsBaseVertexEXT", false));
    glMultiDrawElementsBaseVertexOES = reinterpret_cast<PFNGLMULTIDRAWELEMENTSBASEVERTEXOES>(
            gapic::GetGfxProcAddress("glMultiDrawElementsBaseVertexOES", false));
    glMultiDrawElementsEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSEXT>(
            gapic::GetGfxProcAddress("glMultiDrawElementsEXT", false));
    glMultiDrawElementsIndirectEXT = reinterpret_cast<PFNGLMULTIDRAWELEMENTSINDIRECTEXT>(
            gapic::GetGfxProcAddress("glMultiDrawElementsIndirectEXT", false));
    glPatchParameteriOES = reinterpret_cast<PFNGLPATCHPARAMETERIOES>(
            gapic::GetGfxProcAddress("glPatchParameteriOES", false));
    glPathCommandsNV = reinterpret_cast<PFNGLPATHCOMMANDSNV>(
            gapic::GetGfxProcAddress("glPathCommandsNV", false));
    glPathCoordsNV =
            reinterpret_cast<PFNGLPATHCOORDSNV>(gapic::GetGfxProcAddress("glPathCoordsNV", false));
    glPathCoverDepthFuncNV = reinterpret_cast<PFNGLPATHCOVERDEPTHFUNCNV>(
            gapic::GetGfxProcAddress("glPathCoverDepthFuncNV", false));
    glPathDashArrayNV = reinterpret_cast<PFNGLPATHDASHARRAYNV>(
            gapic::GetGfxProcAddress("glPathDashArrayNV", false));
    glPathGlyphIndexArrayNV = reinterpret_cast<PFNGLPATHGLYPHINDEXARRAYNV>(
            gapic::GetGfxProcAddress("glPathGlyphIndexArrayNV", false));
    glPathGlyphIndexRangeNV = reinterpret_cast<PFNGLPATHGLYPHINDEXRANGENV>(
            gapic::GetGfxProcAddress("glPathGlyphIndexRangeNV", false));
    glPathGlyphRangeNV = reinterpret_cast<PFNGLPATHGLYPHRANGENV>(
            gapic::GetGfxProcAddress("glPathGlyphRangeNV", false));
    glPathGlyphsNV =
            reinterpret_cast<PFNGLPATHGLYPHSNV>(gapic::GetGfxProcAddress("glPathGlyphsNV", false));
    glPathMemoryGlyphIndexArrayNV = reinterpret_cast<PFNGLPATHMEMORYGLYPHINDEXARRAYNV>(
            gapic::GetGfxProcAddress("glPathMemoryGlyphIndexArrayNV", false));
    glPathParameterfNV = reinterpret_cast<PFNGLPATHPARAMETERFNV>(
            gapic::GetGfxProcAddress("glPathParameterfNV", false));
    glPathParameterfvNV = reinterpret_cast<PFNGLPATHPARAMETERFVNV>(
            gapic::GetGfxProcAddress("glPathParameterfvNV", false));
    glPathParameteriNV = reinterpret_cast<PFNGLPATHPARAMETERINV>(
            gapic::GetGfxProcAddress("glPathParameteriNV", false));
    glPathParameterivNV = reinterpret_cast<PFNGLPATHPARAMETERIVNV>(
            gapic::GetGfxProcAddress("glPathParameterivNV", false));
    glPathStencilDepthOffsetNV = reinterpret_cast<PFNGLPATHSTENCILDEPTHOFFSETNV>(
            gapic::GetGfxProcAddress("glPathStencilDepthOffsetNV", false));
    glPathStencilFuncNV = reinterpret_cast<PFNGLPATHSTENCILFUNCNV>(
            gapic::GetGfxProcAddress("glPathStencilFuncNV", false));
    glPathStringNV =
            reinterpret_cast<PFNGLPATHSTRINGNV>(gapic::GetGfxProcAddress("glPathStringNV", false));
    glPathSubCommandsNV = reinterpret_cast<PFNGLPATHSUBCOMMANDSNV>(
            gapic::GetGfxProcAddress("glPathSubCommandsNV", false));
    glPathSubCoordsNV = reinterpret_cast<PFNGLPATHSUBCOORDSNV>(
            gapic::GetGfxProcAddress("glPathSubCoordsNV", false));
    glPointAlongPathNV = reinterpret_cast<PFNGLPOINTALONGPATHNV>(
            gapic::GetGfxProcAddress("glPointAlongPathNV", false));
    glPolygonModeNV = reinterpret_cast<PFNGLPOLYGONMODENV>(
            gapic::GetGfxProcAddress("glPolygonModeNV", false));
    glPopGroupMarkerEXT = reinterpret_cast<PFNGLPOPGROUPMARKEREXT>(
            gapic::GetGfxProcAddress("glPopGroupMarkerEXT", false));
    glPrimitiveBoundingBoxOES = reinterpret_cast<PFNGLPRIMITIVEBOUNDINGBOXOES>(
            gapic::GetGfxProcAddress("glPrimitiveBoundingBoxOES", false));
    glProgramBinaryOES = reinterpret_cast<PFNGLPROGRAMBINARYOES>(
            gapic::GetGfxProcAddress("glProgramBinaryOES", false));
    glProgramParameteriEXT = reinterpret_cast<PFNGLPROGRAMPARAMETERIEXT>(
            gapic::GetGfxProcAddress("glProgramParameteriEXT", false));
    glProgramPathFragmentInputGenNV = reinterpret_cast<PFNGLPROGRAMPATHFRAGMENTINPUTGENNV>(
            gapic::GetGfxProcAddress("glProgramPathFragmentInputGenNV", false));
    glProgramUniform1fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1FEXT>(
            gapic::GetGfxProcAddress("glProgramUniform1fEXT", false));
    glProgramUniform1fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform1fvEXT", false));
    glProgramUniform1iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1IEXT>(
            gapic::GetGfxProcAddress("glProgramUniform1iEXT", false));
    glProgramUniform1ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1IVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform1ivEXT", false));
    glProgramUniform1uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1UIEXT>(
            gapic::GetGfxProcAddress("glProgramUniform1uiEXT", false));
    glProgramUniform1uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM1UIVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform1uivEXT", false));
    glProgramUniform2fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2FEXT>(
            gapic::GetGfxProcAddress("glProgramUniform2fEXT", false));
    glProgramUniform2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform2fvEXT", false));
    glProgramUniform2iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2IEXT>(
            gapic::GetGfxProcAddress("glProgramUniform2iEXT", false));
    glProgramUniform2ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2IVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform2ivEXT", false));
    glProgramUniform2uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2UIEXT>(
            gapic::GetGfxProcAddress("glProgramUniform2uiEXT", false));
    glProgramUniform2uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM2UIVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform2uivEXT", false));
    glProgramUniform3fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3FEXT>(
            gapic::GetGfxProcAddress("glProgramUniform3fEXT", false));
    glProgramUniform3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform3fvEXT", false));
    glProgramUniform3iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3IEXT>(
            gapic::GetGfxProcAddress("glProgramUniform3iEXT", false));
    glProgramUniform3ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3IVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform3ivEXT", false));
    glProgramUniform3uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3UIEXT>(
            gapic::GetGfxProcAddress("glProgramUniform3uiEXT", false));
    glProgramUniform3uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM3UIVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform3uivEXT", false));
    glProgramUniform4fEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4FEXT>(
            gapic::GetGfxProcAddress("glProgramUniform4fEXT", false));
    glProgramUniform4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform4fvEXT", false));
    glProgramUniform4iEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4IEXT>(
            gapic::GetGfxProcAddress("glProgramUniform4iEXT", false));
    glProgramUniform4ivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4IVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform4ivEXT", false));
    glProgramUniform4uiEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4UIEXT>(
            gapic::GetGfxProcAddress("glProgramUniform4uiEXT", false));
    glProgramUniform4uivEXT = reinterpret_cast<PFNGLPROGRAMUNIFORM4UIVEXT>(
            gapic::GetGfxProcAddress("glProgramUniform4uivEXT", false));
    glProgramUniformHandleui64NV = reinterpret_cast<PFNGLPROGRAMUNIFORMHANDLEUI64NV>(
            gapic::GetGfxProcAddress("glProgramUniformHandleui64NV", false));
    glProgramUniformHandleui64vNV = reinterpret_cast<PFNGLPROGRAMUNIFORMHANDLEUI64VNV>(
            gapic::GetGfxProcAddress("glProgramUniformHandleui64vNV", false));
    glProgramUniformMatrix2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix2fvEXT", false));
    glProgramUniformMatrix2x3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X3FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix2x3fvEXT", false));
    glProgramUniformMatrix2x4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X4FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix2x4fvEXT", false));
    glProgramUniformMatrix3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix3fvEXT", false));
    glProgramUniformMatrix3x2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X2FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix3x2fvEXT", false));
    glProgramUniformMatrix3x4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X4FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix3x4fvEXT", false));
    glProgramUniformMatrix4fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix4fvEXT", false));
    glProgramUniformMatrix4x2fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X2FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix4x2fvEXT", false));
    glProgramUniformMatrix4x3fvEXT = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X3FVEXT>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix4x3fvEXT", false));
    glPushGroupMarkerEXT = reinterpret_cast<PFNGLPUSHGROUPMARKEREXT>(
            gapic::GetGfxProcAddress("glPushGroupMarkerEXT", false));
    glQueryCounterEXT = reinterpret_cast<PFNGLQUERYCOUNTEREXT>(
            gapic::GetGfxProcAddress("glQueryCounterEXT", false));
    glReadBufferIndexedEXT = reinterpret_cast<PFNGLREADBUFFERINDEXEDEXT>(
            gapic::GetGfxProcAddress("glReadBufferIndexedEXT", false));
    glReadBufferNV =
            reinterpret_cast<PFNGLREADBUFFERNV>(gapic::GetGfxProcAddress("glReadBufferNV", false));
    glReadnPixelsEXT = reinterpret_cast<PFNGLREADNPIXELSEXT>(
            gapic::GetGfxProcAddress("glReadnPixelsEXT", false));
    glReadnPixelsKHR = reinterpret_cast<PFNGLREADNPIXELSKHR>(
            gapic::GetGfxProcAddress("glReadnPixelsKHR", false));
    glRenderbufferStorageMultisampleANGLE =
            reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLE>(
                    gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleANGLE", false));
    glRenderbufferStorageMultisampleAPPLE =
            reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLE>(
                    gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleAPPLE", false));
    glRenderbufferStorageMultisampleEXT = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXT>(
            gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleEXT", false));
    glRenderbufferStorageMultisampleIMG = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG>(
            gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleIMG", false));
    glRenderbufferStorageMultisampleNV = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLENV>(
            gapic::GetGfxProcAddress("glRenderbufferStorageMultisampleNV", false));
    glResolveMultisampleFramebufferAPPLE =
            reinterpret_cast<PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLE>(
                    gapic::GetGfxProcAddress("glResolveMultisampleFramebufferAPPLE", false));
    glSamplerParameterIivOES = reinterpret_cast<PFNGLSAMPLERPARAMETERIIVOES>(
            gapic::GetGfxProcAddress("glSamplerParameterIivOES", false));
    glSamplerParameterIuivOES = reinterpret_cast<PFNGLSAMPLERPARAMETERIUIVOES>(
            gapic::GetGfxProcAddress("glSamplerParameterIuivOES", false));
    glScissorArrayvNV = reinterpret_cast<PFNGLSCISSORARRAYVNV>(
            gapic::GetGfxProcAddress("glScissorArrayvNV", false));
    glScissorIndexedNV = reinterpret_cast<PFNGLSCISSORINDEXEDNV>(
            gapic::GetGfxProcAddress("glScissorIndexedNV", false));
    glScissorIndexedvNV = reinterpret_cast<PFNGLSCISSORINDEXEDVNV>(
            gapic::GetGfxProcAddress("glScissorIndexedvNV", false));
    glSelectPerfMonitorCountersAMD = reinterpret_cast<PFNGLSELECTPERFMONITORCOUNTERSAMD>(
            gapic::GetGfxProcAddress("glSelectPerfMonitorCountersAMD", false));
    glSetFenceNV =
            reinterpret_cast<PFNGLSETFENCENV>(gapic::GetGfxProcAddress("glSetFenceNV", false));
    glStartTilingQCOM = reinterpret_cast<PFNGLSTARTTILINGQCOM>(
            gapic::GetGfxProcAddress("glStartTilingQCOM", false));
    glStencilFillPathInstancedNV = reinterpret_cast<PFNGLSTENCILFILLPATHINSTANCEDNV>(
            gapic::GetGfxProcAddress("glStencilFillPathInstancedNV", false));
    glStencilFillPathNV = reinterpret_cast<PFNGLSTENCILFILLPATHNV>(
            gapic::GetGfxProcAddress("glStencilFillPathNV", false));
    glStencilStrokePathInstancedNV = reinterpret_cast<PFNGLSTENCILSTROKEPATHINSTANCEDNV>(
            gapic::GetGfxProcAddress("glStencilStrokePathInstancedNV", false));
    glStencilStrokePathNV = reinterpret_cast<PFNGLSTENCILSTROKEPATHNV>(
            gapic::GetGfxProcAddress("glStencilStrokePathNV", false));
    glStencilThenCoverFillPathInstancedNV =
            reinterpret_cast<PFNGLSTENCILTHENCOVERFILLPATHINSTANCEDNV>(
                    gapic::GetGfxProcAddress("glStencilThenCoverFillPathInstancedNV", false));
    glStencilThenCoverFillPathNV = reinterpret_cast<PFNGLSTENCILTHENCOVERFILLPATHNV>(
            gapic::GetGfxProcAddress("glStencilThenCoverFillPathNV", false));
    glStencilThenCoverStrokePathInstancedNV =
            reinterpret_cast<PFNGLSTENCILTHENCOVERSTROKEPATHINSTANCEDNV>(
                    gapic::GetGfxProcAddress("glStencilThenCoverStrokePathInstancedNV", false));
    glStencilThenCoverStrokePathNV = reinterpret_cast<PFNGLSTENCILTHENCOVERSTROKEPATHNV>(
            gapic::GetGfxProcAddress("glStencilThenCoverStrokePathNV", false));
    glTestFenceNV =
            reinterpret_cast<PFNGLTESTFENCENV>(gapic::GetGfxProcAddress("glTestFenceNV", false));
    glTexBufferOES =
            reinterpret_cast<PFNGLTEXBUFFEROES>(gapic::GetGfxProcAddress("glTexBufferOES", false));
    glTexBufferRangeOES = reinterpret_cast<PFNGLTEXBUFFERRANGEOES>(
            gapic::GetGfxProcAddress("glTexBufferRangeOES", false));
    glTexImage3DOES = reinterpret_cast<PFNGLTEXIMAGE3DOES>(
            gapic::GetGfxProcAddress("glTexImage3DOES", false));
    glTexPageCommitmentARB = reinterpret_cast<PFNGLTEXPAGECOMMITMENTARB>(
            gapic::GetGfxProcAddress("glTexPageCommitmentARB", false));
    glTexParameterIivOES = reinterpret_cast<PFNGLTEXPARAMETERIIVOES>(
            gapic::GetGfxProcAddress("glTexParameterIivOES", false));
    glTexParameterIuivOES = reinterpret_cast<PFNGLTEXPARAMETERIUIVOES>(
            gapic::GetGfxProcAddress("glTexParameterIuivOES", false));
    glTexStorage1DEXT = reinterpret_cast<PFNGLTEXSTORAGE1DEXT>(
            gapic::GetGfxProcAddress("glTexStorage1DEXT", false));
    glTexStorage2DEXT = reinterpret_cast<PFNGLTEXSTORAGE2DEXT>(
            gapic::GetGfxProcAddress("glTexStorage2DEXT", false));
    glTexStorage3DEXT = reinterpret_cast<PFNGLTEXSTORAGE3DEXT>(
            gapic::GetGfxProcAddress("glTexStorage3DEXT", false));
    glTexSubImage3DOES = reinterpret_cast<PFNGLTEXSUBIMAGE3DOES>(
            gapic::GetGfxProcAddress("glTexSubImage3DOES", false));
    glTextureStorage1DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE1DEXT>(
            gapic::GetGfxProcAddress("glTextureStorage1DEXT", false));
    glTextureStorage2DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE2DEXT>(
            gapic::GetGfxProcAddress("glTextureStorage2DEXT", false));
    glTextureStorage3DEXT = reinterpret_cast<PFNGLTEXTURESTORAGE3DEXT>(
            gapic::GetGfxProcAddress("glTextureStorage3DEXT", false));
    glTextureViewEXT = reinterpret_cast<PFNGLTEXTUREVIEWEXT>(
            gapic::GetGfxProcAddress("glTextureViewEXT", false));
    glTextureViewOES = reinterpret_cast<PFNGLTEXTUREVIEWOES>(
            gapic::GetGfxProcAddress("glTextureViewOES", false));
    glTransformPathNV = reinterpret_cast<PFNGLTRANSFORMPATHNV>(
            gapic::GetGfxProcAddress("glTransformPathNV", false));
    glUniformHandleui64NV = reinterpret_cast<PFNGLUNIFORMHANDLEUI64NV>(
            gapic::GetGfxProcAddress("glUniformHandleui64NV", false));
    glUniformHandleui64vNV = reinterpret_cast<PFNGLUNIFORMHANDLEUI64VNV>(
            gapic::GetGfxProcAddress("glUniformHandleui64vNV", false));
    glUniformMatrix2x3fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX2X3FVNV>(
            gapic::GetGfxProcAddress("glUniformMatrix2x3fvNV", false));
    glUniformMatrix2x4fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX2X4FVNV>(
            gapic::GetGfxProcAddress("glUniformMatrix2x4fvNV", false));
    glUniformMatrix3x2fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX3X2FVNV>(
            gapic::GetGfxProcAddress("glUniformMatrix3x2fvNV", false));
    glUniformMatrix3x4fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX3X4FVNV>(
            gapic::GetGfxProcAddress("glUniformMatrix3x4fvNV", false));
    glUniformMatrix4x2fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX4X2FVNV>(
            gapic::GetGfxProcAddress("glUniformMatrix4x2fvNV", false));
    glUniformMatrix4x3fvNV = reinterpret_cast<PFNGLUNIFORMMATRIX4X3FVNV>(
            gapic::GetGfxProcAddress("glUniformMatrix4x3fvNV", false));
    glUnmapBufferOES = reinterpret_cast<PFNGLUNMAPBUFFEROES>(
            gapic::GetGfxProcAddress("glUnmapBufferOES", false));
    glUseProgramStagesEXT = reinterpret_cast<PFNGLUSEPROGRAMSTAGESEXT>(
            gapic::GetGfxProcAddress("glUseProgramStagesEXT", false));
    glValidateProgramPipelineEXT = reinterpret_cast<PFNGLVALIDATEPROGRAMPIPELINEEXT>(
            gapic::GetGfxProcAddress("glValidateProgramPipelineEXT", false));
    glVertexAttribDivisorANGLE = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORANGLE>(
            gapic::GetGfxProcAddress("glVertexAttribDivisorANGLE", false));
    glVertexAttribDivisorEXT = reinterpret_cast<PFNGLVERTEXATTRIBDIVISOREXT>(
            gapic::GetGfxProcAddress("glVertexAttribDivisorEXT", false));
    glVertexAttribDivisorNV = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORNV>(
            gapic::GetGfxProcAddress("glVertexAttribDivisorNV", false));
    glViewportArrayvNV = reinterpret_cast<PFNGLVIEWPORTARRAYVNV>(
            gapic::GetGfxProcAddress("glViewportArrayvNV", false));
    glViewportIndexedfNV = reinterpret_cast<PFNGLVIEWPORTINDEXEDFNV>(
            gapic::GetGfxProcAddress("glViewportIndexedfNV", false));
    glViewportIndexedfvNV = reinterpret_cast<PFNGLVIEWPORTINDEXEDFVNV>(
            gapic::GetGfxProcAddress("glViewportIndexedfvNV", false));
    glWaitSyncAPPLE = reinterpret_cast<PFNGLWAITSYNCAPPLE>(
            gapic::GetGfxProcAddress("glWaitSyncAPPLE", false));
    glWeightPathsNV = reinterpret_cast<PFNGLWEIGHTPATHSNV>(
            gapic::GetGfxProcAddress("glWeightPathsNV", false));
    glCoverageModulationNV = reinterpret_cast<PFNGLCOVERAGEMODULATIONNV>(
            gapic::GetGfxProcAddress("glCoverageModulationNV", false));
    glCoverageModulationTableNV = reinterpret_cast<PFNGLCOVERAGEMODULATIONTABLENV>(
            gapic::GetGfxProcAddress("glCoverageModulationTableNV", false));
    glFragmentCoverageColorNV = reinterpret_cast<PFNGLFRAGMENTCOVERAGECOLORNV>(
            gapic::GetGfxProcAddress("glFragmentCoverageColorNV", false));
    glFramebufferSampleLocationsfvNV = reinterpret_cast<PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNV>(
            gapic::GetGfxProcAddress("glFramebufferSampleLocationsfvNV", false));
    glGetCoverageModulationTableNV = reinterpret_cast<PFNGLGETCOVERAGEMODULATIONTABLENV>(
            gapic::GetGfxProcAddress("glGetCoverageModulationTableNV", false));
    glNamedFramebufferSampleLocationsfvNV =
            reinterpret_cast<PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV>(
                    gapic::GetGfxProcAddress("glNamedFramebufferSampleLocationsfvNV", false));
    glRasterSamplesEXT = reinterpret_cast<PFNGLRASTERSAMPLESEXT>(
            gapic::GetGfxProcAddress("glRasterSamplesEXT", false));
    glResolveDepthValuesNV = reinterpret_cast<PFNGLRESOLVEDEPTHVALUESNV>(
            gapic::GetGfxProcAddress("glResolveDepthValuesNV", false));
    glSubpixelPrecisionBiasNV = reinterpret_cast<PFNGLSUBPIXELPRECISIONBIASNV>(
            gapic::GetGfxProcAddress("glSubpixelPrecisionBiasNV", false));
    glBlendColor =
            reinterpret_cast<PFNGLBLENDCOLOR>(gapic::GetGfxProcAddress("glBlendColor", false));
    glBlendEquation = reinterpret_cast<PFNGLBLENDEQUATION>(
            gapic::GetGfxProcAddress("glBlendEquation", false));
    glBlendEquationSeparate = reinterpret_cast<PFNGLBLENDEQUATIONSEPARATE>(
            gapic::GetGfxProcAddress("glBlendEquationSeparate", false));
    glBlendFunc = reinterpret_cast<PFNGLBLENDFUNC>(gapic::GetGfxProcAddress("glBlendFunc", false));
    glBlendFuncSeparate = reinterpret_cast<PFNGLBLENDFUNCSEPARATE>(
            gapic::GetGfxProcAddress("glBlendFuncSeparate", false));
    glDepthFunc = reinterpret_cast<PFNGLDEPTHFUNC>(gapic::GetGfxProcAddress("glDepthFunc", false));
    glSampleCoverage = reinterpret_cast<PFNGLSAMPLECOVERAGE>(
            gapic::GetGfxProcAddress("glSampleCoverage", false));
    glSampleMaski =
            reinterpret_cast<PFNGLSAMPLEMASKI>(gapic::GetGfxProcAddress("glSampleMaski", false));
    glScissor = reinterpret_cast<PFNGLSCISSOR>(gapic::GetGfxProcAddress("glScissor", false));
    glStencilFunc =
            reinterpret_cast<PFNGLSTENCILFUNC>(gapic::GetGfxProcAddress("glStencilFunc", false));
    glStencilFuncSeparate = reinterpret_cast<PFNGLSTENCILFUNCSEPARATE>(
            gapic::GetGfxProcAddress("glStencilFuncSeparate", false));
    glStencilOp = reinterpret_cast<PFNGLSTENCILOP>(gapic::GetGfxProcAddress("glStencilOp", false));
    glStencilOpSeparate = reinterpret_cast<PFNGLSTENCILOPSEPARATE>(
            gapic::GetGfxProcAddress("glStencilOpSeparate", false));
    glBindFramebuffer = reinterpret_cast<PFNGLBINDFRAMEBUFFER>(
            gapic::GetGfxProcAddress("glBindFramebuffer", false));
    glBindRenderbuffer = reinterpret_cast<PFNGLBINDRENDERBUFFER>(
            gapic::GetGfxProcAddress("glBindRenderbuffer", false));
    glBlitFramebuffer = reinterpret_cast<PFNGLBLITFRAMEBUFFER>(
            gapic::GetGfxProcAddress("glBlitFramebuffer", false));
    glCheckFramebufferStatus = reinterpret_cast<PFNGLCHECKFRAMEBUFFERSTATUS>(
            gapic::GetGfxProcAddress("glCheckFramebufferStatus", false));
    glClear = reinterpret_cast<PFNGLCLEAR>(gapic::GetGfxProcAddress("glClear", false));
    glClearBufferfi = reinterpret_cast<PFNGLCLEARBUFFERFI>(
            gapic::GetGfxProcAddress("glClearBufferfi", false));
    glClearBufferfv = reinterpret_cast<PFNGLCLEARBUFFERFV>(
            gapic::GetGfxProcAddress("glClearBufferfv", false));
    glClearBufferiv = reinterpret_cast<PFNGLCLEARBUFFERIV>(
            gapic::GetGfxProcAddress("glClearBufferiv", false));
    glClearBufferuiv = reinterpret_cast<PFNGLCLEARBUFFERUIV>(
            gapic::GetGfxProcAddress("glClearBufferuiv", false));
    glClearColor =
            reinterpret_cast<PFNGLCLEARCOLOR>(gapic::GetGfxProcAddress("glClearColor", false));
    glClearDepthf =
            reinterpret_cast<PFNGLCLEARDEPTHF>(gapic::GetGfxProcAddress("glClearDepthf", false));
    glClearStencil =
            reinterpret_cast<PFNGLCLEARSTENCIL>(gapic::GetGfxProcAddress("glClearStencil", false));
    glColorMask = reinterpret_cast<PFNGLCOLORMASK>(gapic::GetGfxProcAddress("glColorMask", false));
    glDeleteFramebuffers = reinterpret_cast<PFNGLDELETEFRAMEBUFFERS>(
            gapic::GetGfxProcAddress("glDeleteFramebuffers", false));
    glDeleteRenderbuffers = reinterpret_cast<PFNGLDELETERENDERBUFFERS>(
            gapic::GetGfxProcAddress("glDeleteRenderbuffers", false));
    glDepthMask = reinterpret_cast<PFNGLDEPTHMASK>(gapic::GetGfxProcAddress("glDepthMask", false));
    glFramebufferParameteri = reinterpret_cast<PFNGLFRAMEBUFFERPARAMETERI>(
            gapic::GetGfxProcAddress("glFramebufferParameteri", false));
    glFramebufferRenderbuffer = reinterpret_cast<PFNGLFRAMEBUFFERRENDERBUFFER>(
            gapic::GetGfxProcAddress("glFramebufferRenderbuffer", false));
    glFramebufferTexture2D = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2D>(
            gapic::GetGfxProcAddress("glFramebufferTexture2D", false));
    glFramebufferTextureLayer = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURELAYER>(
            gapic::GetGfxProcAddress("glFramebufferTextureLayer", false));
    glGenFramebuffers = reinterpret_cast<PFNGLGENFRAMEBUFFERS>(
            gapic::GetGfxProcAddress("glGenFramebuffers", false));
    glGenRenderbuffers = reinterpret_cast<PFNGLGENRENDERBUFFERS>(
            gapic::GetGfxProcAddress("glGenRenderbuffers", false));
    glGetFramebufferAttachmentParameteriv =
            reinterpret_cast<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV>(
                    gapic::GetGfxProcAddress("glGetFramebufferAttachmentParameteriv", false));
    glGetFramebufferParameteriv = reinterpret_cast<PFNGLGETFRAMEBUFFERPARAMETERIV>(
            gapic::GetGfxProcAddress("glGetFramebufferParameteriv", false));
    glGetRenderbufferParameteriv = reinterpret_cast<PFNGLGETRENDERBUFFERPARAMETERIV>(
            gapic::GetGfxProcAddress("glGetRenderbufferParameteriv", false));
    glInvalidateFramebuffer = reinterpret_cast<PFNGLINVALIDATEFRAMEBUFFER>(
            gapic::GetGfxProcAddress("glInvalidateFramebuffer", false));
    glInvalidateSubFramebuffer = reinterpret_cast<PFNGLINVALIDATESUBFRAMEBUFFER>(
            gapic::GetGfxProcAddress("glInvalidateSubFramebuffer", false));
    glIsFramebuffer = reinterpret_cast<PFNGLISFRAMEBUFFER>(
            gapic::GetGfxProcAddress("glIsFramebuffer", false));
    glIsRenderbuffer = reinterpret_cast<PFNGLISRENDERBUFFER>(
            gapic::GetGfxProcAddress("glIsRenderbuffer", false));
    glReadBuffer =
            reinterpret_cast<PFNGLREADBUFFER>(gapic::GetGfxProcAddress("glReadBuffer", false));
    glReadPixels =
            reinterpret_cast<PFNGLREADPIXELS>(gapic::GetGfxProcAddress("glReadPixels", false));
    glRenderbufferStorage = reinterpret_cast<PFNGLRENDERBUFFERSTORAGE>(
            gapic::GetGfxProcAddress("glRenderbufferStorage", false));
    glRenderbufferStorageMultisample = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLE>(
            gapic::GetGfxProcAddress("glRenderbufferStorageMultisample", false));
    glStencilMask =
            reinterpret_cast<PFNGLSTENCILMASK>(gapic::GetGfxProcAddress("glStencilMask", false));
    glStencilMaskSeparate = reinterpret_cast<PFNGLSTENCILMASKSEPARATE>(
            gapic::GetGfxProcAddress("glStencilMaskSeparate", false));
    glDisable = reinterpret_cast<PFNGLDISABLE>(gapic::GetGfxProcAddress("glDisable", false));
    glEnable = reinterpret_cast<PFNGLENABLE>(gapic::GetGfxProcAddress("glEnable", false));
    glFinish = reinterpret_cast<PFNGLFINISH>(gapic::GetGfxProcAddress("glFinish", false));
    glFlush = reinterpret_cast<PFNGLFLUSH>(gapic::GetGfxProcAddress("glFlush", false));
    glFlushMappedBufferRange = reinterpret_cast<PFNGLFLUSHMAPPEDBUFFERRANGE>(
            gapic::GetGfxProcAddress("glFlushMappedBufferRange", false));
    glGetError = reinterpret_cast<PFNGLGETERROR>(gapic::GetGfxProcAddress("glGetError", false));
    glHint = reinterpret_cast<PFNGLHINT>(gapic::GetGfxProcAddress("glHint", false));
    glActiveShaderProgram = reinterpret_cast<PFNGLACTIVESHADERPROGRAM>(
            gapic::GetGfxProcAddress("glActiveShaderProgram", false));
    glAttachShader =
            reinterpret_cast<PFNGLATTACHSHADER>(gapic::GetGfxProcAddress("glAttachShader", false));
    glBindAttribLocation = reinterpret_cast<PFNGLBINDATTRIBLOCATION>(
            gapic::GetGfxProcAddress("glBindAttribLocation", false));
    glBindProgramPipeline = reinterpret_cast<PFNGLBINDPROGRAMPIPELINE>(
            gapic::GetGfxProcAddress("glBindProgramPipeline", false));
    glCompileShader = reinterpret_cast<PFNGLCOMPILESHADER>(
            gapic::GetGfxProcAddress("glCompileShader", false));
    glCreateProgram = reinterpret_cast<PFNGLCREATEPROGRAM>(
            gapic::GetGfxProcAddress("glCreateProgram", false));
    glCreateShader =
            reinterpret_cast<PFNGLCREATESHADER>(gapic::GetGfxProcAddress("glCreateShader", false));
    glCreateShaderProgramv = reinterpret_cast<PFNGLCREATESHADERPROGRAMV>(
            gapic::GetGfxProcAddress("glCreateShaderProgramv", false));
    glDeleteProgram = reinterpret_cast<PFNGLDELETEPROGRAM>(
            gapic::GetGfxProcAddress("glDeleteProgram", false));
    glDeleteProgramPipelines = reinterpret_cast<PFNGLDELETEPROGRAMPIPELINES>(
            gapic::GetGfxProcAddress("glDeleteProgramPipelines", false));
    glDeleteShader =
            reinterpret_cast<PFNGLDELETESHADER>(gapic::GetGfxProcAddress("glDeleteShader", false));
    glDetachShader =
            reinterpret_cast<PFNGLDETACHSHADER>(gapic::GetGfxProcAddress("glDetachShader", false));
    glDispatchCompute = reinterpret_cast<PFNGLDISPATCHCOMPUTE>(
            gapic::GetGfxProcAddress("glDispatchCompute", false));
    glDispatchComputeIndirect = reinterpret_cast<PFNGLDISPATCHCOMPUTEINDIRECT>(
            gapic::GetGfxProcAddress("glDispatchComputeIndirect", false));
    glGenProgramPipelines = reinterpret_cast<PFNGLGENPROGRAMPIPELINES>(
            gapic::GetGfxProcAddress("glGenProgramPipelines", false));
    glGetActiveAttrib = reinterpret_cast<PFNGLGETACTIVEATTRIB>(
            gapic::GetGfxProcAddress("glGetActiveAttrib", false));
    glGetActiveUniform = reinterpret_cast<PFNGLGETACTIVEUNIFORM>(
            gapic::GetGfxProcAddress("glGetActiveUniform", false));
    glGetActiveUniformBlockName = reinterpret_cast<PFNGLGETACTIVEUNIFORMBLOCKNAME>(
            gapic::GetGfxProcAddress("glGetActiveUniformBlockName", false));
    glGetActiveUniformBlockiv = reinterpret_cast<PFNGLGETACTIVEUNIFORMBLOCKIV>(
            gapic::GetGfxProcAddress("glGetActiveUniformBlockiv", false));
    glGetActiveUniformsiv = reinterpret_cast<PFNGLGETACTIVEUNIFORMSIV>(
            gapic::GetGfxProcAddress("glGetActiveUniformsiv", false));
    glGetAttachedShaders = reinterpret_cast<PFNGLGETATTACHEDSHADERS>(
            gapic::GetGfxProcAddress("glGetAttachedShaders", false));
    glGetAttribLocation = reinterpret_cast<PFNGLGETATTRIBLOCATION>(
            gapic::GetGfxProcAddress("glGetAttribLocation", false));
    glGetFragDataLocation = reinterpret_cast<PFNGLGETFRAGDATALOCATION>(
            gapic::GetGfxProcAddress("glGetFragDataLocation", false));
    glGetProgramBinary = reinterpret_cast<PFNGLGETPROGRAMBINARY>(
            gapic::GetGfxProcAddress("glGetProgramBinary", false));
    glGetProgramInfoLog = reinterpret_cast<PFNGLGETPROGRAMINFOLOG>(
            gapic::GetGfxProcAddress("glGetProgramInfoLog", false));
    glGetProgramInterfaceiv = reinterpret_cast<PFNGLGETPROGRAMINTERFACEIV>(
            gapic::GetGfxProcAddress("glGetProgramInterfaceiv", false));
    glGetProgramPipelineInfoLog = reinterpret_cast<PFNGLGETPROGRAMPIPELINEINFOLOG>(
            gapic::GetGfxProcAddress("glGetProgramPipelineInfoLog", false));
    glGetProgramPipelineiv = reinterpret_cast<PFNGLGETPROGRAMPIPELINEIV>(
            gapic::GetGfxProcAddress("glGetProgramPipelineiv", false));
    glGetProgramResourceIndex = reinterpret_cast<PFNGLGETPROGRAMRESOURCEINDEX>(
            gapic::GetGfxProcAddress("glGetProgramResourceIndex", false));
    glGetProgramResourceLocation = reinterpret_cast<PFNGLGETPROGRAMRESOURCELOCATION>(
            gapic::GetGfxProcAddress("glGetProgramResourceLocation", false));
    glGetProgramResourceName = reinterpret_cast<PFNGLGETPROGRAMRESOURCENAME>(
            gapic::GetGfxProcAddress("glGetProgramResourceName", false));
    glGetProgramResourceiv = reinterpret_cast<PFNGLGETPROGRAMRESOURCEIV>(
            gapic::GetGfxProcAddress("glGetProgramResourceiv", false));
    glGetProgramiv =
            reinterpret_cast<PFNGLGETPROGRAMIV>(gapic::GetGfxProcAddress("glGetProgramiv", false));
    glGetShaderInfoLog = reinterpret_cast<PFNGLGETSHADERINFOLOG>(
            gapic::GetGfxProcAddress("glGetShaderInfoLog", false));
    glGetShaderPrecisionFormat = reinterpret_cast<PFNGLGETSHADERPRECISIONFORMAT>(
            gapic::GetGfxProcAddress("glGetShaderPrecisionFormat", false));
    glGetShaderSource = reinterpret_cast<PFNGLGETSHADERSOURCE>(
            gapic::GetGfxProcAddress("glGetShaderSource", false));
    glGetShaderiv =
            reinterpret_cast<PFNGLGETSHADERIV>(gapic::GetGfxProcAddress("glGetShaderiv", false));
    glGetUniformBlockIndex = reinterpret_cast<PFNGLGETUNIFORMBLOCKINDEX>(
            gapic::GetGfxProcAddress("glGetUniformBlockIndex", false));
    glGetUniformIndices = reinterpret_cast<PFNGLGETUNIFORMINDICES>(
            gapic::GetGfxProcAddress("glGetUniformIndices", false));
    glGetUniformLocation = reinterpret_cast<PFNGLGETUNIFORMLOCATION>(
            gapic::GetGfxProcAddress("glGetUniformLocation", false));
    glGetUniformfv =
            reinterpret_cast<PFNGLGETUNIFORMFV>(gapic::GetGfxProcAddress("glGetUniformfv", false));
    glGetUniformiv =
            reinterpret_cast<PFNGLGETUNIFORMIV>(gapic::GetGfxProcAddress("glGetUniformiv", false));
    glGetUniformuiv = reinterpret_cast<PFNGLGETUNIFORMUIV>(
            gapic::GetGfxProcAddress("glGetUniformuiv", false));
    glIsProgram = reinterpret_cast<PFNGLISPROGRAM>(gapic::GetGfxProcAddress("glIsProgram", false));
    glIsProgramPipeline = reinterpret_cast<PFNGLISPROGRAMPIPELINE>(
            gapic::GetGfxProcAddress("glIsProgramPipeline", false));
    glIsShader = reinterpret_cast<PFNGLISSHADER>(gapic::GetGfxProcAddress("glIsShader", false));
    glLinkProgram =
            reinterpret_cast<PFNGLLINKPROGRAM>(gapic::GetGfxProcAddress("glLinkProgram", false));
    glMemoryBarrier = reinterpret_cast<PFNGLMEMORYBARRIER>(
            gapic::GetGfxProcAddress("glMemoryBarrier", false));
    glMemoryBarrierByRegion = reinterpret_cast<PFNGLMEMORYBARRIERBYREGION>(
            gapic::GetGfxProcAddress("glMemoryBarrierByRegion", false));
    glProgramBinary = reinterpret_cast<PFNGLPROGRAMBINARY>(
            gapic::GetGfxProcAddress("glProgramBinary", false));
    glProgramParameteri = reinterpret_cast<PFNGLPROGRAMPARAMETERI>(
            gapic::GetGfxProcAddress("glProgramParameteri", false));
    glProgramUniform1f = reinterpret_cast<PFNGLPROGRAMUNIFORM1F>(
            gapic::GetGfxProcAddress("glProgramUniform1f", false));
    glProgramUniform1fv = reinterpret_cast<PFNGLPROGRAMUNIFORM1FV>(
            gapic::GetGfxProcAddress("glProgramUniform1fv", false));
    glProgramUniform1i = reinterpret_cast<PFNGLPROGRAMUNIFORM1I>(
            gapic::GetGfxProcAddress("glProgramUniform1i", false));
    glProgramUniform1iv = reinterpret_cast<PFNGLPROGRAMUNIFORM1IV>(
            gapic::GetGfxProcAddress("glProgramUniform1iv", false));
    glProgramUniform1ui = reinterpret_cast<PFNGLPROGRAMUNIFORM1UI>(
            gapic::GetGfxProcAddress("glProgramUniform1ui", false));
    glProgramUniform1uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM1UIV>(
            gapic::GetGfxProcAddress("glProgramUniform1uiv", false));
    glProgramUniform2f = reinterpret_cast<PFNGLPROGRAMUNIFORM2F>(
            gapic::GetGfxProcAddress("glProgramUniform2f", false));
    glProgramUniform2fv = reinterpret_cast<PFNGLPROGRAMUNIFORM2FV>(
            gapic::GetGfxProcAddress("glProgramUniform2fv", false));
    glProgramUniform2i = reinterpret_cast<PFNGLPROGRAMUNIFORM2I>(
            gapic::GetGfxProcAddress("glProgramUniform2i", false));
    glProgramUniform2iv = reinterpret_cast<PFNGLPROGRAMUNIFORM2IV>(
            gapic::GetGfxProcAddress("glProgramUniform2iv", false));
    glProgramUniform2ui = reinterpret_cast<PFNGLPROGRAMUNIFORM2UI>(
            gapic::GetGfxProcAddress("glProgramUniform2ui", false));
    glProgramUniform2uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM2UIV>(
            gapic::GetGfxProcAddress("glProgramUniform2uiv", false));
    glProgramUniform3f = reinterpret_cast<PFNGLPROGRAMUNIFORM3F>(
            gapic::GetGfxProcAddress("glProgramUniform3f", false));
    glProgramUniform3fv = reinterpret_cast<PFNGLPROGRAMUNIFORM3FV>(
            gapic::GetGfxProcAddress("glProgramUniform3fv", false));
    glProgramUniform3i = reinterpret_cast<PFNGLPROGRAMUNIFORM3I>(
            gapic::GetGfxProcAddress("glProgramUniform3i", false));
    glProgramUniform3iv = reinterpret_cast<PFNGLPROGRAMUNIFORM3IV>(
            gapic::GetGfxProcAddress("glProgramUniform3iv", false));
    glProgramUniform3ui = reinterpret_cast<PFNGLPROGRAMUNIFORM3UI>(
            gapic::GetGfxProcAddress("glProgramUniform3ui", false));
    glProgramUniform3uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM3UIV>(
            gapic::GetGfxProcAddress("glProgramUniform3uiv", false));
    glProgramUniform4f = reinterpret_cast<PFNGLPROGRAMUNIFORM4F>(
            gapic::GetGfxProcAddress("glProgramUniform4f", false));
    glProgramUniform4fv = reinterpret_cast<PFNGLPROGRAMUNIFORM4FV>(
            gapic::GetGfxProcAddress("glProgramUniform4fv", false));
    glProgramUniform4i = reinterpret_cast<PFNGLPROGRAMUNIFORM4I>(
            gapic::GetGfxProcAddress("glProgramUniform4i", false));
    glProgramUniform4iv = reinterpret_cast<PFNGLPROGRAMUNIFORM4IV>(
            gapic::GetGfxProcAddress("glProgramUniform4iv", false));
    glProgramUniform4ui = reinterpret_cast<PFNGLPROGRAMUNIFORM4UI>(
            gapic::GetGfxProcAddress("glProgramUniform4ui", false));
    glProgramUniform4uiv = reinterpret_cast<PFNGLPROGRAMUNIFORM4UIV>(
            gapic::GetGfxProcAddress("glProgramUniform4uiv", false));
    glProgramUniformMatrix2fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix2fv", false));
    glProgramUniformMatrix2x3fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X3FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix2x3fv", false));
    glProgramUniformMatrix2x4fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX2X4FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix2x4fv", false));
    glProgramUniformMatrix3fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix3fv", false));
    glProgramUniformMatrix3x2fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X2FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix3x2fv", false));
    glProgramUniformMatrix3x4fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX3X4FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix3x4fv", false));
    glProgramUniformMatrix4fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix4fv", false));
    glProgramUniformMatrix4x2fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X2FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix4x2fv", false));
    glProgramUniformMatrix4x3fv = reinterpret_cast<PFNGLPROGRAMUNIFORMMATRIX4X3FV>(
            gapic::GetGfxProcAddress("glProgramUniformMatrix4x3fv", false));
    glReleaseShaderCompiler = reinterpret_cast<PFNGLRELEASESHADERCOMPILER>(
            gapic::GetGfxProcAddress("glReleaseShaderCompiler", false));
    glShaderBinary =
            reinterpret_cast<PFNGLSHADERBINARY>(gapic::GetGfxProcAddress("glShaderBinary", false));
    glShaderSource =
            reinterpret_cast<PFNGLSHADERSOURCE>(gapic::GetGfxProcAddress("glShaderSource", false));
    glUniform1f = reinterpret_cast<PFNGLUNIFORM1F>(gapic::GetGfxProcAddress("glUniform1f", false));
    glUniform1fv =
            reinterpret_cast<PFNGLUNIFORM1FV>(gapic::GetGfxProcAddress("glUniform1fv", false));
    glUniform1i = reinterpret_cast<PFNGLUNIFORM1I>(gapic::GetGfxProcAddress("glUniform1i", false));
    glUniform1iv =
            reinterpret_cast<PFNGLUNIFORM1IV>(gapic::GetGfxProcAddress("glUniform1iv", false));
    glUniform1ui =
            reinterpret_cast<PFNGLUNIFORM1UI>(gapic::GetGfxProcAddress("glUniform1ui", false));
    glUniform1uiv =
            reinterpret_cast<PFNGLUNIFORM1UIV>(gapic::GetGfxProcAddress("glUniform1uiv", false));
    glUniform2f = reinterpret_cast<PFNGLUNIFORM2F>(gapic::GetGfxProcAddress("glUniform2f", false));
    glUniform2fv =
            reinterpret_cast<PFNGLUNIFORM2FV>(gapic::GetGfxProcAddress("glUniform2fv", false));
    glUniform2i = reinterpret_cast<PFNGLUNIFORM2I>(gapic::GetGfxProcAddress("glUniform2i", false));
    glUniform2iv =
            reinterpret_cast<PFNGLUNIFORM2IV>(gapic::GetGfxProcAddress("glUniform2iv", false));
    glUniform2ui =
            reinterpret_cast<PFNGLUNIFORM2UI>(gapic::GetGfxProcAddress("glUniform2ui", false));
    glUniform2uiv =
            reinterpret_cast<PFNGLUNIFORM2UIV>(gapic::GetGfxProcAddress("glUniform2uiv", false));
    glUniform3f = reinterpret_cast<PFNGLUNIFORM3F>(gapic::GetGfxProcAddress("glUniform3f", false));
    glUniform3fv =
            reinterpret_cast<PFNGLUNIFORM3FV>(gapic::GetGfxProcAddress("glUniform3fv", false));
    glUniform3i = reinterpret_cast<PFNGLUNIFORM3I>(gapic::GetGfxProcAddress("glUniform3i", false));
    glUniform3iv =
            reinterpret_cast<PFNGLUNIFORM3IV>(gapic::GetGfxProcAddress("glUniform3iv", false));
    glUniform3ui =
            reinterpret_cast<PFNGLUNIFORM3UI>(gapic::GetGfxProcAddress("glUniform3ui", false));
    glUniform3uiv =
            reinterpret_cast<PFNGLUNIFORM3UIV>(gapic::GetGfxProcAddress("glUniform3uiv", false));
    glUniform4f = reinterpret_cast<PFNGLUNIFORM4F>(gapic::GetGfxProcAddress("glUniform4f", false));
    glUniform4fv =
            reinterpret_cast<PFNGLUNIFORM4FV>(gapic::GetGfxProcAddress("glUniform4fv", false));
    glUniform4i = reinterpret_cast<PFNGLUNIFORM4I>(gapic::GetGfxProcAddress("glUniform4i", false));
    glUniform4iv =
            reinterpret_cast<PFNGLUNIFORM4IV>(gapic::GetGfxProcAddress("glUniform4iv", false));
    glUniform4ui =
            reinterpret_cast<PFNGLUNIFORM4UI>(gapic::GetGfxProcAddress("glUniform4ui", false));
    glUniform4uiv =
            reinterpret_cast<PFNGLUNIFORM4UIV>(gapic::GetGfxProcAddress("glUniform4uiv", false));
    glUniformBlockBinding = reinterpret_cast<PFNGLUNIFORMBLOCKBINDING>(
            gapic::GetGfxProcAddress("glUniformBlockBinding", false));
    glUniformMatrix2fv = reinterpret_cast<PFNGLUNIFORMMATRIX2FV>(
            gapic::GetGfxProcAddress("glUniformMatrix2fv", false));
    glUniformMatrix2x3fv = reinterpret_cast<PFNGLUNIFORMMATRIX2X3FV>(
            gapic::GetGfxProcAddress("glUniformMatrix2x3fv", false));
    glUniformMatrix2x4fv = reinterpret_cast<PFNGLUNIFORMMATRIX2X4FV>(
            gapic::GetGfxProcAddress("glUniformMatrix2x4fv", false));
    glUniformMatrix3fv = reinterpret_cast<PFNGLUNIFORMMATRIX3FV>(
            gapic::GetGfxProcAddress("glUniformMatrix3fv", false));
    glUniformMatrix3x2fv = reinterpret_cast<PFNGLUNIFORMMATRIX3X2FV>(
            gapic::GetGfxProcAddress("glUniformMatrix3x2fv", false));
    glUniformMatrix3x4fv = reinterpret_cast<PFNGLUNIFORMMATRIX3X4FV>(
            gapic::GetGfxProcAddress("glUniformMatrix3x4fv", false));
    glUniformMatrix4fv = reinterpret_cast<PFNGLUNIFORMMATRIX4FV>(
            gapic::GetGfxProcAddress("glUniformMatrix4fv", false));
    glUniformMatrix4x2fv = reinterpret_cast<PFNGLUNIFORMMATRIX4X2FV>(
            gapic::GetGfxProcAddress("glUniformMatrix4x2fv", false));
    glUniformMatrix4x3fv = reinterpret_cast<PFNGLUNIFORMMATRIX4X3FV>(
            gapic::GetGfxProcAddress("glUniformMatrix4x3fv", false));
    glUseProgram =
            reinterpret_cast<PFNGLUSEPROGRAM>(gapic::GetGfxProcAddress("glUseProgram", false));
    glUseProgramStages = reinterpret_cast<PFNGLUSEPROGRAMSTAGES>(
            gapic::GetGfxProcAddress("glUseProgramStages", false));
    glValidateProgram = reinterpret_cast<PFNGLVALIDATEPROGRAM>(
            gapic::GetGfxProcAddress("glValidateProgram", false));
    glValidateProgramPipeline = reinterpret_cast<PFNGLVALIDATEPROGRAMPIPELINE>(
            gapic::GetGfxProcAddress("glValidateProgramPipeline", false));
    glCullFace = reinterpret_cast<PFNGLCULLFACE>(gapic::GetGfxProcAddress("glCullFace", false));
    glDepthRangef =
            reinterpret_cast<PFNGLDEPTHRANGEF>(gapic::GetGfxProcAddress("glDepthRangef", false));
    glFrontFace = reinterpret_cast<PFNGLFRONTFACE>(gapic::GetGfxProcAddress("glFrontFace", false));
    glGetMultisamplefv = reinterpret_cast<PFNGLGETMULTISAMPLEFV>(
            gapic::GetGfxProcAddress("glGetMultisamplefv", false));
    glLineWidth = reinterpret_cast<PFNGLLINEWIDTH>(gapic::GetGfxProcAddress("glLineWidth", false));
    glPolygonOffset = reinterpret_cast<PFNGLPOLYGONOFFSET>(
            gapic::GetGfxProcAddress("glPolygonOffset", false));
    glViewport = reinterpret_cast<PFNGLVIEWPORT>(gapic::GetGfxProcAddress("glViewport", false));
    glGetBooleani_v = reinterpret_cast<PFNGLGETBOOLEANI_V>(
            gapic::GetGfxProcAddress("glGetBooleani_v", false));
    glGetBooleanv =
            reinterpret_cast<PFNGLGETBOOLEANV>(gapic::GetGfxProcAddress("glGetBooleanv", false));
    glGetFloatv = reinterpret_cast<PFNGLGETFLOATV>(gapic::GetGfxProcAddress("glGetFloatv", false));
    glGetInteger64i_v = reinterpret_cast<PFNGLGETINTEGER64I_V>(
            gapic::GetGfxProcAddress("glGetInteger64i_v", false));
    glGetInteger64v = reinterpret_cast<PFNGLGETINTEGER64V>(
            gapic::GetGfxProcAddress("glGetInteger64v", false));
    glGetIntegeri_v = reinterpret_cast<PFNGLGETINTEGERI_V>(
            gapic::GetGfxProcAddress("glGetIntegeri_v", false));
    glGetIntegerv =
            reinterpret_cast<PFNGLGETINTEGERV>(gapic::GetGfxProcAddress("glGetIntegerv", false));
    glGetInternalformativ = reinterpret_cast<PFNGLGETINTERNALFORMATIV>(
            gapic::GetGfxProcAddress("glGetInternalformativ", false));
    glGetString = reinterpret_cast<PFNGLGETSTRING>(gapic::GetGfxProcAddress("glGetString", false));
    glGetStringi =
            reinterpret_cast<PFNGLGETSTRINGI>(gapic::GetGfxProcAddress("glGetStringi", false));
    glIsEnabled = reinterpret_cast<PFNGLISENABLED>(gapic::GetGfxProcAddress("glIsEnabled", false));
    glClientWaitSync = reinterpret_cast<PFNGLCLIENTWAITSYNC>(
            gapic::GetGfxProcAddress("glClientWaitSync", false));
    glDeleteSync =
            reinterpret_cast<PFNGLDELETESYNC>(gapic::GetGfxProcAddress("glDeleteSync", false));
    glFenceSync = reinterpret_cast<PFNGLFENCESYNC>(gapic::GetGfxProcAddress("glFenceSync", false));
    glGetSynciv = reinterpret_cast<PFNGLGETSYNCIV>(gapic::GetGfxProcAddress("glGetSynciv", false));
    glIsSync = reinterpret_cast<PFNGLISSYNC>(gapic::GetGfxProcAddress("glIsSync", false));
    glWaitSync = reinterpret_cast<PFNGLWAITSYNC>(gapic::GetGfxProcAddress("glWaitSync", false));
    glActiveTexture = reinterpret_cast<PFNGLACTIVETEXTURE>(
            gapic::GetGfxProcAddress("glActiveTexture", false));
    glBindImageTexture = reinterpret_cast<PFNGLBINDIMAGETEXTURE>(
            gapic::GetGfxProcAddress("glBindImageTexture", false));
    glBindSampler =
            reinterpret_cast<PFNGLBINDSAMPLER>(gapic::GetGfxProcAddress("glBindSampler", false));
    glBindTexture =
            reinterpret_cast<PFNGLBINDTEXTURE>(gapic::GetGfxProcAddress("glBindTexture", false));
    glCompressedTexImage2D = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE2D>(
            gapic::GetGfxProcAddress("glCompressedTexImage2D", false));
    glCompressedTexImage3D = reinterpret_cast<PFNGLCOMPRESSEDTEXIMAGE3D>(
            gapic::GetGfxProcAddress("glCompressedTexImage3D", false));
    glCompressedTexSubImage2D = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE2D>(
            gapic::GetGfxProcAddress("glCompressedTexSubImage2D", false));
    glCompressedTexSubImage3D = reinterpret_cast<PFNGLCOMPRESSEDTEXSUBIMAGE3D>(
            gapic::GetGfxProcAddress("glCompressedTexSubImage3D", false));
    glCopyTexImage2D = reinterpret_cast<PFNGLCOPYTEXIMAGE2D>(
            gapic::GetGfxProcAddress("glCopyTexImage2D", false));
    glCopyTexSubImage2D = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE2D>(
            gapic::GetGfxProcAddress("glCopyTexSubImage2D", false));
    glCopyTexSubImage3D = reinterpret_cast<PFNGLCOPYTEXSUBIMAGE3D>(
            gapic::GetGfxProcAddress("glCopyTexSubImage3D", false));
    glDeleteSamplers = reinterpret_cast<PFNGLDELETESAMPLERS>(
            gapic::GetGfxProcAddress("glDeleteSamplers", false));
    glDeleteTextures = reinterpret_cast<PFNGLDELETETEXTURES>(
            gapic::GetGfxProcAddress("glDeleteTextures", false));
    glGenSamplers =
            reinterpret_cast<PFNGLGENSAMPLERS>(gapic::GetGfxProcAddress("glGenSamplers", false));
    glGenTextures =
            reinterpret_cast<PFNGLGENTEXTURES>(gapic::GetGfxProcAddress("glGenTextures", false));
    glGenerateMipmap = reinterpret_cast<PFNGLGENERATEMIPMAP>(
            gapic::GetGfxProcAddress("glGenerateMipmap", false));
    glGetSamplerParameterfv = reinterpret_cast<PFNGLGETSAMPLERPARAMETERFV>(
            gapic::GetGfxProcAddress("glGetSamplerParameterfv", false));
    glGetSamplerParameteriv = reinterpret_cast<PFNGLGETSAMPLERPARAMETERIV>(
            gapic::GetGfxProcAddress("glGetSamplerParameteriv", false));
    glGetTexLevelParameterfv = reinterpret_cast<PFNGLGETTEXLEVELPARAMETERFV>(
            gapic::GetGfxProcAddress("glGetTexLevelParameterfv", false));
    glGetTexLevelParameteriv = reinterpret_cast<PFNGLGETTEXLEVELPARAMETERIV>(
            gapic::GetGfxProcAddress("glGetTexLevelParameteriv", false));
    glGetTexParameterfv = reinterpret_cast<PFNGLGETTEXPARAMETERFV>(
            gapic::GetGfxProcAddress("glGetTexParameterfv", false));
    glGetTexParameteriv = reinterpret_cast<PFNGLGETTEXPARAMETERIV>(
            gapic::GetGfxProcAddress("glGetTexParameteriv", false));
    glIsSampler = reinterpret_cast<PFNGLISSAMPLER>(gapic::GetGfxProcAddress("glIsSampler", false));
    glIsTexture = reinterpret_cast<PFNGLISTEXTURE>(gapic::GetGfxProcAddress("glIsTexture", false));
    glPixelStorei =
            reinterpret_cast<PFNGLPIXELSTOREI>(gapic::GetGfxProcAddress("glPixelStorei", false));
    glSamplerParameterf = reinterpret_cast<PFNGLSAMPLERPARAMETERF>(
            gapic::GetGfxProcAddress("glSamplerParameterf", false));
    glSamplerParameterfv = reinterpret_cast<PFNGLSAMPLERPARAMETERFV>(
            gapic::GetGfxProcAddress("glSamplerParameterfv", false));
    glSamplerParameteri = reinterpret_cast<PFNGLSAMPLERPARAMETERI>(
            gapic::GetGfxProcAddress("glSamplerParameteri", false));
    glSamplerParameteriv = reinterpret_cast<PFNGLSAMPLERPARAMETERIV>(
            gapic::GetGfxProcAddress("glSamplerParameteriv", false));
    glTexImage2D =
            reinterpret_cast<PFNGLTEXIMAGE2D>(gapic::GetGfxProcAddress("glTexImage2D", false));
    glTexImage3D =
            reinterpret_cast<PFNGLTEXIMAGE3D>(gapic::GetGfxProcAddress("glTexImage3D", false));
    glTexParameterf = reinterpret_cast<PFNGLTEXPARAMETERF>(
            gapic::GetGfxProcAddress("glTexParameterf", false));
    glTexParameterfv = reinterpret_cast<PFNGLTEXPARAMETERFV>(
            gapic::GetGfxProcAddress("glTexParameterfv", false));
    glTexParameteri = reinterpret_cast<PFNGLTEXPARAMETERI>(
            gapic::GetGfxProcAddress("glTexParameteri", false));
    glTexParameteriv = reinterpret_cast<PFNGLTEXPARAMETERIV>(
            gapic::GetGfxProcAddress("glTexParameteriv", false));
    glTexStorage2D =
            reinterpret_cast<PFNGLTEXSTORAGE2D>(gapic::GetGfxProcAddress("glTexStorage2D", false));
    glTexStorage2DMultisample = reinterpret_cast<PFNGLTEXSTORAGE2DMULTISAMPLE>(
            gapic::GetGfxProcAddress("glTexStorage2DMultisample", false));
    glTexStorage3D =
            reinterpret_cast<PFNGLTEXSTORAGE3D>(gapic::GetGfxProcAddress("glTexStorage3D", false));
    glTexSubImage2D = reinterpret_cast<PFNGLTEXSUBIMAGE2D>(
            gapic::GetGfxProcAddress("glTexSubImage2D", false));
    glTexSubImage3D = reinterpret_cast<PFNGLTEXSUBIMAGE3D>(
            gapic::GetGfxProcAddress("glTexSubImage3D", false));
    glBeginTransformFeedback = reinterpret_cast<PFNGLBEGINTRANSFORMFEEDBACK>(
            gapic::GetGfxProcAddress("glBeginTransformFeedback", false));
    glBindTransformFeedback = reinterpret_cast<PFNGLBINDTRANSFORMFEEDBACK>(
            gapic::GetGfxProcAddress("glBindTransformFeedback", false));
    glDeleteTransformFeedbacks = reinterpret_cast<PFNGLDELETETRANSFORMFEEDBACKS>(
            gapic::GetGfxProcAddress("glDeleteTransformFeedbacks", false));
    glEndTransformFeedback = reinterpret_cast<PFNGLENDTRANSFORMFEEDBACK>(
            gapic::GetGfxProcAddress("glEndTransformFeedback", false));
    glGenTransformFeedbacks = reinterpret_cast<PFNGLGENTRANSFORMFEEDBACKS>(
            gapic::GetGfxProcAddress("glGenTransformFeedbacks", false));
    glGetTransformFeedbackVarying = reinterpret_cast<PFNGLGETTRANSFORMFEEDBACKVARYING>(
            gapic::GetGfxProcAddress("glGetTransformFeedbackVarying", false));
    glIsTransformFeedback = reinterpret_cast<PFNGLISTRANSFORMFEEDBACK>(
            gapic::GetGfxProcAddress("glIsTransformFeedback", false));
    glPauseTransformFeedback = reinterpret_cast<PFNGLPAUSETRANSFORMFEEDBACK>(
            gapic::GetGfxProcAddress("glPauseTransformFeedback", false));
    glResumeTransformFeedback = reinterpret_cast<PFNGLRESUMETRANSFORMFEEDBACK>(
            gapic::GetGfxProcAddress("glResumeTransformFeedback", false));
    glTransformFeedbackVaryings = reinterpret_cast<PFNGLTRANSFORMFEEDBACKVARYINGS>(
            gapic::GetGfxProcAddress("glTransformFeedbackVaryings", false));
    glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAY>(
            gapic::GetGfxProcAddress("glBindVertexArray", false));
    glBindVertexBuffer = reinterpret_cast<PFNGLBINDVERTEXBUFFER>(
            gapic::GetGfxProcAddress("glBindVertexBuffer", false));
    glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYS>(
            gapic::GetGfxProcAddress("glDeleteVertexArrays", false));
    glDisableVertexAttribArray = reinterpret_cast<PFNGLDISABLEVERTEXATTRIBARRAY>(
            gapic::GetGfxProcAddress("glDisableVertexAttribArray", false));
    glEnableVertexAttribArray = reinterpret_cast<PFNGLENABLEVERTEXATTRIBARRAY>(
            gapic::GetGfxProcAddress("glEnableVertexAttribArray", false));
    glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYS>(
            gapic::GetGfxProcAddress("glGenVertexArrays", false));
    glGetVertexAttribIiv = reinterpret_cast<PFNGLGETVERTEXATTRIBIIV>(
            gapic::GetGfxProcAddress("glGetVertexAttribIiv", false));
    glGetVertexAttribIuiv = reinterpret_cast<PFNGLGETVERTEXATTRIBIUIV>(
            gapic::GetGfxProcAddress("glGetVertexAttribIuiv", false));
    glGetVertexAttribPointerv = reinterpret_cast<PFNGLGETVERTEXATTRIBPOINTERV>(
            gapic::GetGfxProcAddress("glGetVertexAttribPointerv", false));
    glGetVertexAttribfv = reinterpret_cast<PFNGLGETVERTEXATTRIBFV>(
            gapic::GetGfxProcAddress("glGetVertexAttribfv", false));
    glGetVertexAttribiv = reinterpret_cast<PFNGLGETVERTEXATTRIBIV>(
            gapic::GetGfxProcAddress("glGetVertexAttribiv", false));
    glIsVertexArray = reinterpret_cast<PFNGLISVERTEXARRAY>(
            gapic::GetGfxProcAddress("glIsVertexArray", false));
    glVertexAttrib1f = reinterpret_cast<PFNGLVERTEXATTRIB1F>(
            gapic::GetGfxProcAddress("glVertexAttrib1f", false));
    glVertexAttrib1fv = reinterpret_cast<PFNGLVERTEXATTRIB1FV>(
            gapic::GetGfxProcAddress("glVertexAttrib1fv", false));
    glVertexAttrib2f = reinterpret_cast<PFNGLVERTEXATTRIB2F>(
            gapic::GetGfxProcAddress("glVertexAttrib2f", false));
    glVertexAttrib2fv = reinterpret_cast<PFNGLVERTEXATTRIB2FV>(
            gapic::GetGfxProcAddress("glVertexAttrib2fv", false));
    glVertexAttrib3f = reinterpret_cast<PFNGLVERTEXATTRIB3F>(
            gapic::GetGfxProcAddress("glVertexAttrib3f", false));
    glVertexAttrib3fv = reinterpret_cast<PFNGLVERTEXATTRIB3FV>(
            gapic::GetGfxProcAddress("glVertexAttrib3fv", false));
    glVertexAttrib4f = reinterpret_cast<PFNGLVERTEXATTRIB4F>(
            gapic::GetGfxProcAddress("glVertexAttrib4f", false));
    glVertexAttrib4fv = reinterpret_cast<PFNGLVERTEXATTRIB4FV>(
            gapic::GetGfxProcAddress("glVertexAttrib4fv", false));
    glVertexAttribBinding = reinterpret_cast<PFNGLVERTEXATTRIBBINDING>(
            gapic::GetGfxProcAddress("glVertexAttribBinding", false));
    glVertexAttribDivisor = reinterpret_cast<PFNGLVERTEXATTRIBDIVISOR>(
            gapic::GetGfxProcAddress("glVertexAttribDivisor", false));
    glVertexAttribFormat = reinterpret_cast<PFNGLVERTEXATTRIBFORMAT>(
            gapic::GetGfxProcAddress("glVertexAttribFormat", false));
    glVertexAttribI4i = reinterpret_cast<PFNGLVERTEXATTRIBI4I>(
            gapic::GetGfxProcAddress("glVertexAttribI4i", false));
    glVertexAttribI4iv = reinterpret_cast<PFNGLVERTEXATTRIBI4IV>(
            gapic::GetGfxProcAddress("glVertexAttribI4iv", false));
    glVertexAttribI4ui = reinterpret_cast<PFNGLVERTEXATTRIBI4UI>(
            gapic::GetGfxProcAddress("glVertexAttribI4ui", false));
    glVertexAttribI4uiv = reinterpret_cast<PFNGLVERTEXATTRIBI4UIV>(
            gapic::GetGfxProcAddress("glVertexAttribI4uiv", false));
    glVertexAttribIFormat = reinterpret_cast<PFNGLVERTEXATTRIBIFORMAT>(
            gapic::GetGfxProcAddress("glVertexAttribIFormat", false));
    glVertexAttribIPointer = reinterpret_cast<PFNGLVERTEXATTRIBIPOINTER>(
            gapic::GetGfxProcAddress("glVertexAttribIPointer", false));
    glVertexAttribPointer = reinterpret_cast<PFNGLVERTEXATTRIBPOINTER>(
            gapic::GetGfxProcAddress("glVertexAttribPointer", false));
    glVertexBindingDivisor = reinterpret_cast<PFNGLVERTEXBINDINGDIVISOR>(
            gapic::GetGfxProcAddress("glVertexBindingDivisor", false));
    eglInitialize =
            reinterpret_cast<PFNEGLINITIALIZE>(gapic::GetGfxProcAddress("eglInitialize", false));
    eglCreateContext = reinterpret_cast<PFNEGLCREATECONTEXT>(
            gapic::GetGfxProcAddress("eglCreateContext", false));
    eglMakeCurrent =
            reinterpret_cast<PFNEGLMAKECURRENT>(gapic::GetGfxProcAddress("eglMakeCurrent", false));
    eglSwapBuffers =
            reinterpret_cast<PFNEGLSWAPBUFFERS>(gapic::GetGfxProcAddress("eglSwapBuffers", false));
    eglQuerySurface = reinterpret_cast<PFNEGLQUERYSURFACE>(
            gapic::GetGfxProcAddress("eglQuerySurface", false));
    glXCreateContext = reinterpret_cast<PFNGLXCREATECONTEXT>(
            gapic::GetGfxProcAddress("glXCreateContext", false));
    glXCreateNewContext = reinterpret_cast<PFNGLXCREATENEWCONTEXT>(
            gapic::GetGfxProcAddress("glXCreateNewContext", false));
    glXMakeContextCurrent = reinterpret_cast<PFNGLXMAKECONTEXTCURRENT>(
            gapic::GetGfxProcAddress("glXMakeContextCurrent", false));
    glXMakeCurrent =
            reinterpret_cast<PFNGLXMAKECURRENT>(gapic::GetGfxProcAddress("glXMakeCurrent", false));
    glXSwapBuffers =
            reinterpret_cast<PFNGLXSWAPBUFFERS>(gapic::GetGfxProcAddress("glXSwapBuffers", false));
    glXQueryDrawable = reinterpret_cast<PFNGLXQUERYDRAWABLE>(
            gapic::GetGfxProcAddress("glXQueryDrawable", false));
    wglCreateContext = reinterpret_cast<PFNWGLCREATECONTEXT>(
            gapic::GetGfxProcAddress("wglCreateContext", false));
    wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARB>(
            gapic::GetGfxProcAddress("wglCreateContextAttribsARB", false));
    wglMakeCurrent =
            reinterpret_cast<PFNWGLMAKECURRENT>(gapic::GetGfxProcAddress("wglMakeCurrent", false));
    wglSwapBuffers =
            reinterpret_cast<PFNWGLSWAPBUFFERS>(gapic::GetGfxProcAddress("wglSwapBuffers", false));
    CGLCreateContext = reinterpret_cast<PFNCGLCREATECONTEXT>(
            gapic::GetGfxProcAddress("CGLCreateContext", false));
    CGLSetCurrentContext = reinterpret_cast<PFNCGLSETCURRENTCONTEXT>(
            gapic::GetGfxProcAddress("CGLSetCurrentContext", false));
    CGLGetSurface =
            reinterpret_cast<PFNCGLGETSURFACE>(gapic::GetGfxProcAddress("CGLGetSurface", false));
    CGSGetSurfaceBounds = reinterpret_cast<PFNCGSGETSURFACEBOUNDS>(
            gapic::GetGfxProcAddress("CGSGetSurfaceBounds", false));
    CGLFlushDrawable = reinterpret_cast<PFNCGLFLUSHDRAWABLE>(
            gapic::GetGfxProcAddress("CGLFlushDrawable", false));
    glGetQueryObjecti64v = reinterpret_cast<PFNGLGETQUERYOBJECTI64V>(
            gapic::GetGfxProcAddress("glGetQueryObjecti64v", false));
    glGetQueryObjectui64v = reinterpret_cast<PFNGLGETQUERYOBJECTUI64V>(
            gapic::GetGfxProcAddress("glGetQueryObjectui64v", false));
}

}  // namespace gfxapi
}  // namespace gapir