OpenHarmony-v3.0.8-LTS/s

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_gl_dispatch_table.py using data from gl_bindings_data.json and gl.xml.
//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// DispatchTableGL_autogen.cpp:
//   Initialize the native bindings for ANGLE's OpenGL back-end.

#include "libANGLE/renderer/gl/DispatchTableGL_autogen.h"

#include "libANGLE/Version.h"
#include "libANGLE/renderer/gl/FunctionsGL.h"

#if defined(ANGLE_ENABLE_OPENGL_NULL)
#    include "libANGLE/renderer/gl/null_functions.h"
#endif  // defined(ANGLE_ENABLE_OPENGL_NULL)

// Check for nullptr so extensions do not overwrite core imports.
#define ASSIGN(NAME, FP) \
    if (!FP)             \
    *reinterpret_cast<void **>(&FP) = loadProcAddress(NAME)

namespace rx
{
DispatchTableGL::DispatchTableGL() = default;

void DispatchTableGL::initProcsDesktopGL(const gl::Version &version,
                                         const std::set<std::string> &extensions)
{
    if (version >= gl::Version(1, 0))
    {
        ASSIGN("glBlendFunc", blendFunc);
        ASSIGN("glClear", clear);
        ASSIGN("glClearColor", clearColor);
        ASSIGN("glClearDepth", clearDepth);
        ASSIGN("glClearStencil", clearStencil);
        ASSIGN("glColorMask", colorMask);
        ASSIGN("glCullFace", cullFace);
        ASSIGN("glDepthFunc", depthFunc);
        ASSIGN("glDepthMask", depthMask);
        ASSIGN("glDepthRange", depthRange);
        ASSIGN("glDisable", disable);
        ASSIGN("glDrawBuffer", drawBuffer);
        ASSIGN("glEnable", enable);
        ASSIGN("glFinish", finish);
        ASSIGN("glFlush", flush);
        ASSIGN("glFrontFace", frontFace);
        ASSIGN("glGetBooleanv", getBooleanv);
        ASSIGN("glGetDoublev", getDoublev);
        ASSIGN("glGetError", getError);
        ASSIGN("glGetFloatv", getFloatv);
        ASSIGN("glGetIntegerv", getIntegerv);
        ASSIGN("glGetString", getString);
        ASSIGN("glGetTexImage", getTexImage);
        ASSIGN("glGetTexLevelParameterfv", getTexLevelParameterfv);
        ASSIGN("glGetTexLevelParameteriv", getTexLevelParameteriv);
        ASSIGN("glGetTexParameterfv", getTexParameterfv);
        ASSIGN("glGetTexParameteriv", getTexParameteriv);
        ASSIGN("glHint", hint);
        ASSIGN("glIsEnabled", isEnabled);
        ASSIGN("glLineWidth", lineWidth);
        ASSIGN("glLogicOp", logicOp);
        ASSIGN("glPixelStoref", pixelStoref);
        ASSIGN("glPixelStorei", pixelStorei);
        ASSIGN("glPointSize", pointSize);
        ASSIGN("glPolygonMode", polygonMode);
        ASSIGN("glReadBuffer", readBuffer);
        ASSIGN("glReadPixels", readPixels);
        ASSIGN("glScissor", scissor);
        ASSIGN("glStencilFunc", stencilFunc);
        ASSIGN("glStencilMask", stencilMask);
        ASSIGN("glStencilOp", stencilOp);
        ASSIGN("glTexImage1D", texImage1D);
        ASSIGN("glTexImage2D", texImage2D);
        ASSIGN("glTexParameterf", texParameterf);
        ASSIGN("glTexParameterfv", texParameterfv);
        ASSIGN("glTexParameteri", texParameteri);
        ASSIGN("glTexParameteriv", texParameteriv);
        ASSIGN("glViewport", viewport);
    }

    if (version >= gl::Version(1, 1))
    {
        ASSIGN("glBindTexture", bindTexture);
        ASSIGN("glCopyTexImage1D", copyTexImage1D);
        ASSIGN("glCopyTexImage2D", copyTexImage2D);
        ASSIGN("glCopyTexSubImage1D", copyTexSubImage1D);
        ASSIGN("glCopyTexSubImage2D", copyTexSubImage2D);
        ASSIGN("glDeleteTextures", deleteTextures);
        ASSIGN("glDrawArrays", drawArrays);
        ASSIGN("glDrawElements", drawElements);
        ASSIGN("glGenTextures", genTextures);
        ASSIGN("glIsTexture", isTexture);
        ASSIGN("glPolygonOffset", polygonOffset);
        ASSIGN("glTexSubImage1D", texSubImage1D);
        ASSIGN("glTexSubImage2D", texSubImage2D);
    }

    if (version >= gl::Version(1, 2))
    {
        ASSIGN("glCopyTexSubImage3D", copyTexSubImage3D);
        ASSIGN("glDrawRangeElements", drawRangeElements);
        ASSIGN("glTexImage3D", texImage3D);
        ASSIGN("glTexSubImage3D", texSubImage3D);
    }

    if (version >= gl::Version(1, 3))
    {
        ASSIGN("glActiveTexture", activeTexture);
        ASSIGN("glCompressedTexImage1D", compressedTexImage1D);
        ASSIGN("glCompressedTexImage2D", compressedTexImage2D);
        ASSIGN("glCompressedTexImage3D", compressedTexImage3D);
        ASSIGN("glCompressedTexSubImage1D", compressedTexSubImage1D);
        ASSIGN("glCompressedTexSubImage2D", compressedTexSubImage2D);
        ASSIGN("glCompressedTexSubImage3D", compressedTexSubImage3D);
        ASSIGN("glGetCompressedTexImage", getCompressedTexImage);
        ASSIGN("glSampleCoverage", sampleCoverage);
    }

    if (version >= gl::Version(1, 4))
    {
        ASSIGN("glBlendColor", blendColor);
        ASSIGN("glBlendEquation", blendEquation);
        ASSIGN("glBlendFuncSeparate", blendFuncSeparate);
        ASSIGN("glMultiDrawArrays", multiDrawArrays);
        ASSIGN("glMultiDrawElements", multiDrawElements);
        ASSIGN("glPointParameterf", pointParameterf);
        ASSIGN("glPointParameterfv", pointParameterfv);
        ASSIGN("glPointParameteri", pointParameteri);
        ASSIGN("glPointParameteriv", pointParameteriv);
    }

    if (version >= gl::Version(1, 5))
    {
        ASSIGN("glBeginQuery", beginQuery);
        ASSIGN("glBindBuffer", bindBuffer);
        ASSIGN("glBufferData", bufferData);
        ASSIGN("glBufferSubData", bufferSubData);
        ASSIGN("glDeleteBuffers", deleteBuffers);
        ASSIGN("glDeleteQueries", deleteQueries);
        ASSIGN("glEndQuery", endQuery);
        ASSIGN("glGenBuffers", genBuffers);
        ASSIGN("glGenQueries", genQueries);
        ASSIGN("glGetBufferParameteriv", getBufferParameteriv);
        ASSIGN("glGetBufferPointerv", getBufferPointerv);
        ASSIGN("glGetBufferSubData", getBufferSubData);
        ASSIGN("glGetQueryObjectiv", getQueryObjectiv);
        ASSIGN("glGetQueryObjectuiv", getQueryObjectuiv);
        ASSIGN("glGetQueryiv", getQueryiv);
        ASSIGN("glIsBuffer", isBuffer);
        ASSIGN("glIsQuery", isQuery);
        ASSIGN("glMapBuffer", mapBuffer);
        ASSIGN("glUnmapBuffer", unmapBuffer);
    }

    if (version >= gl::Version(2, 0))
    {
        ASSIGN("glAttachShader", attachShader);
        ASSIGN("glBindAttribLocation", bindAttribLocation);
        ASSIGN("glBlendEquationSeparate", blendEquationSeparate);
        ASSIGN("glCompileShader", compileShader);
        ASSIGN("glCreateProgram", createProgram);
        ASSIGN("glCreateShader", createShader);
        ASSIGN("glDeleteProgram", deleteProgram);
        ASSIGN("glDeleteShader", deleteShader);
        ASSIGN("glDetachShader", detachShader);
        ASSIGN("glDisableVertexAttribArray", disableVertexAttribArray);
        ASSIGN("glDrawBuffers", drawBuffers);
        ASSIGN("glEnableVertexAttribArray", enableVertexAttribArray);
        ASSIGN("glGetActiveAttrib", getActiveAttrib);
        ASSIGN("glGetActiveUniform", getActiveUniform);
        ASSIGN("glGetAttachedShaders", getAttachedShaders);
        ASSIGN("glGetAttribLocation", getAttribLocation);
        ASSIGN("glGetProgramInfoLog", getProgramInfoLog);
        ASSIGN("glGetProgramiv", getProgramiv);
        ASSIGN("glGetShaderInfoLog", getShaderInfoLog);
        ASSIGN("glGetShaderSource", getShaderSource);
        ASSIGN("glGetShaderiv", getShaderiv);
        ASSIGN("glGetUniformLocation", getUniformLocation);
        ASSIGN("glGetUniformfv", getUniformfv);
        ASSIGN("glGetUniformiv", getUniformiv);
        ASSIGN("glGetVertexAttribPointerv", getVertexAttribPointerv);
        ASSIGN("glGetVertexAttribdv", getVertexAttribdv);
        ASSIGN("glGetVertexAttribfv", getVertexAttribfv);
        ASSIGN("glGetVertexAttribiv", getVertexAttribiv);
        ASSIGN("glIsProgram", isProgram);
        ASSIGN("glIsShader", isShader);
        ASSIGN("glLinkProgram", linkProgram);
        ASSIGN("glShaderSource", shaderSource);
        ASSIGN("glStencilFuncSeparate", stencilFuncSeparate);
        ASSIGN("glStencilMaskSeparate", stencilMaskSeparate);
        ASSIGN("glStencilOpSeparate", stencilOpSeparate);
        ASSIGN("glUniform1f", uniform1f);
        ASSIGN("glUniform1fv", uniform1fv);
        ASSIGN("glUniform1i", uniform1i);
        ASSIGN("glUniform1iv", uniform1iv);
        ASSIGN("glUniform2f", uniform2f);
        ASSIGN("glUniform2fv", uniform2fv);
        ASSIGN("glUniform2i", uniform2i);
        ASSIGN("glUniform2iv", uniform2iv);
        ASSIGN("glUniform3f", uniform3f);
        ASSIGN("glUniform3fv", uniform3fv);
        ASSIGN("glUniform3i", uniform3i);
        ASSIGN("glUniform3iv", uniform3iv);
        ASSIGN("glUniform4f", uniform4f);
        ASSIGN("glUniform4fv", uniform4fv);
        ASSIGN("glUniform4i", uniform4i);
        ASSIGN("glUniform4iv", uniform4iv);
        ASSIGN("glUniformMatrix2fv", uniformMatrix2fv);
        ASSIGN("glUniformMatrix3fv", uniformMatrix3fv);
        ASSIGN("glUniformMatrix4fv", uniformMatrix4fv);
        ASSIGN("glUseProgram", useProgram);
        ASSIGN("glValidateProgram", validateProgram);
        ASSIGN("glVertexAttrib1d", vertexAttrib1d);
        ASSIGN("glVertexAttrib1dv", vertexAttrib1dv);
        ASSIGN("glVertexAttrib1f", vertexAttrib1f);
        ASSIGN("glVertexAttrib1fv", vertexAttrib1fv);
        ASSIGN("glVertexAttrib1s", vertexAttrib1s);
        ASSIGN("glVertexAttrib1sv", vertexAttrib1sv);
        ASSIGN("glVertexAttrib2d", vertexAttrib2d);
        ASSIGN("glVertexAttrib2dv", vertexAttrib2dv);
        ASSIGN("glVertexAttrib2f", vertexAttrib2f);
        ASSIGN("glVertexAttrib2fv", vertexAttrib2fv);
        ASSIGN("glVertexAttrib2s", vertexAttrib2s);
        ASSIGN("glVertexAttrib2sv", vertexAttrib2sv);
        ASSIGN("glVertexAttrib3d", vertexAttrib3d);
        ASSIGN("glVertexAttrib3dv", vertexAttrib3dv);
        ASSIGN("glVertexAttrib3f", vertexAttrib3f);
        ASSIGN("glVertexAttrib3fv", vertexAttrib3fv);
        ASSIGN("glVertexAttrib3s", vertexAttrib3s);
        ASSIGN("glVertexAttrib3sv", vertexAttrib3sv);
        ASSIGN("glVertexAttrib4Nbv", vertexAttrib4Nbv);
        ASSIGN("glVertexAttrib4Niv", vertexAttrib4Niv);
        ASSIGN("glVertexAttrib4Nsv", vertexAttrib4Nsv);
        ASSIGN("glVertexAttrib4Nub", vertexAttrib4Nub);
        ASSIGN("glVertexAttrib4Nubv", vertexAttrib4Nubv);
        ASSIGN("glVertexAttrib4Nuiv", vertexAttrib4Nuiv);
        ASSIGN("glVertexAttrib4Nusv", vertexAttrib4Nusv);
        ASSIGN("glVertexAttrib4bv", vertexAttrib4bv);
        ASSIGN("glVertexAttrib4d", vertexAttrib4d);
        ASSIGN("glVertexAttrib4dv", vertexAttrib4dv);
        ASSIGN("glVertexAttrib4f", vertexAttrib4f);
        ASSIGN("glVertexAttrib4fv", vertexAttrib4fv);
        ASSIGN("glVertexAttrib4iv", vertexAttrib4iv);
        ASSIGN("glVertexAttrib4s", vertexAttrib4s);
        ASSIGN("glVertexAttrib4sv", vertexAttrib4sv);
        ASSIGN("glVertexAttrib4ubv", vertexAttrib4ubv);
        ASSIGN("glVertexAttrib4uiv", vertexAttrib4uiv);
        ASSIGN("glVertexAttrib4usv", vertexAttrib4usv);
        ASSIGN("glVertexAttribPointer", vertexAttribPointer);
    }

    if (version >= gl::Version(2, 1))
    {
        ASSIGN("glUniformMatrix2x3fv", uniformMatrix2x3fv);
        ASSIGN("glUniformMatrix2x4fv", uniformMatrix2x4fv);
        ASSIGN("glUniformMatrix3x2fv", uniformMatrix3x2fv);
        ASSIGN("glUniformMatrix3x4fv", uniformMatrix3x4fv);
        ASSIGN("glUniformMatrix4x2fv", uniformMatrix4x2fv);
        ASSIGN("glUniformMatrix4x3fv", uniformMatrix4x3fv);
    }

    if (version >= gl::Version(3, 0))
    {
        ASSIGN("glBeginConditionalRender", beginConditionalRender);
        ASSIGN("glBeginTransformFeedback", beginTransformFeedback);
        ASSIGN("glBindBufferBase", bindBufferBase);
        ASSIGN("glBindBufferRange", bindBufferRange);
        ASSIGN("glBindFragDataLocation", bindFragDataLocation);
        ASSIGN("glBindFramebuffer", bindFramebuffer);
        ASSIGN("glBindRenderbuffer", bindRenderbuffer);
        ASSIGN("glBindVertexArray", bindVertexArray);
        ASSIGN("glBlitFramebuffer", blitFramebuffer);
        ASSIGN("glCheckFramebufferStatus", checkFramebufferStatus);
        ASSIGN("glClampColor", clampColor);
        ASSIGN("glClearBufferfi", clearBufferfi);
        ASSIGN("glClearBufferfv", clearBufferfv);
        ASSIGN("glClearBufferiv", clearBufferiv);
        ASSIGN("glClearBufferuiv", clearBufferuiv);
        ASSIGN("glColorMaski", colorMaski);
        ASSIGN("glDeleteFramebuffers", deleteFramebuffers);
        ASSIGN("glDeleteRenderbuffers", deleteRenderbuffers);
        ASSIGN("glDeleteVertexArrays", deleteVertexArrays);
        ASSIGN("glDisablei", disablei);
        ASSIGN("glEnablei", enablei);
        ASSIGN("glEndConditionalRender", endConditionalRender);
        ASSIGN("glEndTransformFeedback", endTransformFeedback);
        ASSIGN("glFlushMappedBufferRange", flushMappedBufferRange);
        ASSIGN("glFramebufferRenderbuffer", framebufferRenderbuffer);
        ASSIGN("glFramebufferTexture1D", framebufferTexture1D);
        ASSIGN("glFramebufferTexture2D", framebufferTexture2D);
        ASSIGN("glFramebufferTexture3D", framebufferTexture3D);
        ASSIGN("glFramebufferTextureLayer", framebufferTextureLayer);
        ASSIGN("glGenFramebuffers", genFramebuffers);
        ASSIGN("glGenRenderbuffers", genRenderbuffers);
        ASSIGN("glGenVertexArrays", genVertexArrays);
        ASSIGN("glGenerateMipmap", generateMipmap);
        ASSIGN("glGetBooleani_v", getBooleani_v);
        ASSIGN("glGetFragDataLocation", getFragDataLocation);
        ASSIGN("glGetFramebufferAttachmentParameteriv", getFramebufferAttachmentParameteriv);
        ASSIGN("glGetIntegeri_v", getIntegeri_v);
        ASSIGN("glGetRenderbufferParameteriv", getRenderbufferParameteriv);
        ASSIGN("glGetStringi", getStringi);
        ASSIGN("glGetTexParameterIiv", getTexParameterIiv);
        ASSIGN("glGetTexParameterIuiv", getTexParameterIuiv);
        ASSIGN("glGetTransformFeedbackVarying", getTransformFeedbackVarying);
        ASSIGN("glGetUniformuiv", getUniformuiv);
        ASSIGN("glGetVertexAttribIiv", getVertexAttribIiv);
        ASSIGN("glGetVertexAttribIuiv", getVertexAttribIuiv);
        ASSIGN("glIsEnabledi", isEnabledi);
        ASSIGN("glIsFramebuffer", isFramebuffer);
        ASSIGN("glIsRenderbuffer", isRenderbuffer);
        ASSIGN("glIsVertexArray", isVertexArray);
        ASSIGN("glMapBufferRange", mapBufferRange);
        ASSIGN("glRenderbufferStorage", renderbufferStorage);
        ASSIGN("glRenderbufferStorageMultisample", renderbufferStorageMultisample);
        ASSIGN("glTexParameterIiv", texParameterIiv);
        ASSIGN("glTexParameterIuiv", texParameterIuiv);
        ASSIGN("glTransformFeedbackVaryings", transformFeedbackVaryings);
        ASSIGN("glUniform1ui", uniform1ui);
        ASSIGN("glUniform1uiv", uniform1uiv);
        ASSIGN("glUniform2ui", uniform2ui);
        ASSIGN("glUniform2uiv", uniform2uiv);
        ASSIGN("glUniform3ui", uniform3ui);
        ASSIGN("glUniform3uiv", uniform3uiv);
        ASSIGN("glUniform4ui", uniform4ui);
        ASSIGN("glUniform4uiv", uniform4uiv);
        ASSIGN("glVertexAttribI1i", vertexAttribI1i);
        ASSIGN("glVertexAttribI1iv", vertexAttribI1iv);
        ASSIGN("glVertexAttribI1ui", vertexAttribI1ui);
        ASSIGN("glVertexAttribI1uiv", vertexAttribI1uiv);
        ASSIGN("glVertexAttribI2i", vertexAttribI2i);
        ASSIGN("glVertexAttribI2iv", vertexAttribI2iv);
        ASSIGN("glVertexAttribI2ui", vertexAttribI2ui);
        ASSIGN("glVertexAttribI2uiv", vertexAttribI2uiv);
        ASSIGN("glVertexAttribI3i", vertexAttribI3i);
        ASSIGN("glVertexAttribI3iv", vertexAttribI3iv);
        ASSIGN("glVertexAttribI3ui", vertexAttribI3ui);
        ASSIGN("glVertexAttribI3uiv", vertexAttribI3uiv);
        ASSIGN("glVertexAttribI4bv", vertexAttribI4bv);
        ASSIGN("glVertexAttribI4i", vertexAttribI4i);
        ASSIGN("glVertexAttribI4iv", vertexAttribI4iv);
        ASSIGN("glVertexAttribI4sv", vertexAttribI4sv);
        ASSIGN("glVertexAttribI4ubv", vertexAttribI4ubv);
        ASSIGN("glVertexAttribI4ui", vertexAttribI4ui);
        ASSIGN("glVertexAttribI4uiv", vertexAttribI4uiv);
        ASSIGN("glVertexAttribI4usv", vertexAttribI4usv);
        ASSIGN("glVertexAttribIPointer", vertexAttribIPointer);
    }

    if (version >= gl::Version(3, 1))
    {
        ASSIGN("glCopyBufferSubData", copyBufferSubData);
        ASSIGN("glDrawArraysInstanced", drawArraysInstanced);
        ASSIGN("glDrawElementsInstanced", drawElementsInstanced);
        ASSIGN("glGetActiveUniformBlockName", getActiveUniformBlockName);
        ASSIGN("glGetActiveUniformBlockiv", getActiveUniformBlockiv);
        ASSIGN("glGetActiveUniformName", getActiveUniformName);
        ASSIGN("glGetActiveUniformsiv", getActiveUniformsiv);
        ASSIGN("glGetUniformBlockIndex", getUniformBlockIndex);
        ASSIGN("glGetUniformIndices", getUniformIndices);
        ASSIGN("glPrimitiveRestartIndex", primitiveRestartIndex);
        ASSIGN("glTexBuffer", texBuffer);
        ASSIGN("glUniformBlockBinding", uniformBlockBinding);
    }

    if (version >= gl::Version(3, 2))
    {
        ASSIGN("glClientWaitSync", clientWaitSync);
        ASSIGN("glDeleteSync", deleteSync);
        ASSIGN("glDrawElementsBaseVertex", drawElementsBaseVertex);
        ASSIGN("glDrawElementsInstancedBaseVertex", drawElementsInstancedBaseVertex);
        ASSIGN("glDrawRangeElementsBaseVertex", drawRangeElementsBaseVertex);
        ASSIGN("glFenceSync", fenceSync);
        ASSIGN("glFramebufferTexture", framebufferTexture);
        ASSIGN("glGetBufferParameteri64v", getBufferParameteri64v);
        ASSIGN("glGetInteger64i_v", getInteger64i_v);
        ASSIGN("glGetInteger64v", getInteger64v);
        ASSIGN("glGetMultisamplefv", getMultisamplefv);
        ASSIGN("glGetSynciv", getSynciv);
        ASSIGN("glIsSync", isSync);
        ASSIGN("glMultiDrawElementsBaseVertex", multiDrawElementsBaseVertex);
        ASSIGN("glProvokingVertex", provokingVertex);
        ASSIGN("glSampleMaski", sampleMaski);
        ASSIGN("glTexImage2DMultisample", texImage2DMultisample);
        ASSIGN("glTexImage3DMultisample", texImage3DMultisample);
        ASSIGN("glWaitSync", waitSync);
    }

    if (version >= gl::Version(3, 3))
    {
        ASSIGN("glBindFragDataLocationIndexed", bindFragDataLocationIndexed);
        ASSIGN("glBindSampler", bindSampler);
        ASSIGN("glDeleteSamplers", deleteSamplers);
        ASSIGN("glGenSamplers", genSamplers);
        ASSIGN("glGetFragDataIndex", getFragDataIndex);
        ASSIGN("glGetQueryObjecti64v", getQueryObjecti64v);
        ASSIGN("glGetQueryObjectui64v", getQueryObjectui64v);
        ASSIGN("glGetSamplerParameterIiv", getSamplerParameterIiv);
        ASSIGN("glGetSamplerParameterIuiv", getSamplerParameterIuiv);
        ASSIGN("glGetSamplerParameterfv", getSamplerParameterfv);
        ASSIGN("glGetSamplerParameteriv", getSamplerParameteriv);
        ASSIGN("glIsSampler", isSampler);
        ASSIGN("glQueryCounter", queryCounter);
        ASSIGN("glSamplerParameterIiv", samplerParameterIiv);
        ASSIGN("glSamplerParameterIuiv", samplerParameterIuiv);
        ASSIGN("glSamplerParameterf", samplerParameterf);
        ASSIGN("glSamplerParameterfv", samplerParameterfv);
        ASSIGN("glSamplerParameteri", samplerParameteri);
        ASSIGN("glSamplerParameteriv", samplerParameteriv);
        ASSIGN("glVertexAttribDivisor", vertexAttribDivisor);
        ASSIGN("glVertexAttribP1ui", vertexAttribP1ui);
        ASSIGN("glVertexAttribP1uiv", vertexAttribP1uiv);
        ASSIGN("glVertexAttribP2ui", vertexAttribP2ui);
        ASSIGN("glVertexAttribP2uiv", vertexAttribP2uiv);
        ASSIGN("glVertexAttribP3ui", vertexAttribP3ui);
        ASSIGN("glVertexAttribP3uiv", vertexAttribP3uiv);
        ASSIGN("glVertexAttribP4ui", vertexAttribP4ui);
        ASSIGN("glVertexAttribP4uiv", vertexAttribP4uiv);
    }

    if (version >= gl::Version(4, 0))
    {
        ASSIGN("glBeginQueryIndexed", beginQueryIndexed);
        ASSIGN("glBindTransformFeedback", bindTransformFeedback);
        ASSIGN("glBlendEquationSeparatei", blendEquationSeparatei);
        ASSIGN("glBlendEquationi", blendEquationi);
        ASSIGN("glBlendFuncSeparatei", blendFuncSeparatei);
        ASSIGN("glBlendFunci", blendFunci);
        ASSIGN("glDeleteTransformFeedbacks", deleteTransformFeedbacks);
        ASSIGN("glDrawArraysIndirect", drawArraysIndirect);
        ASSIGN("glDrawElementsIndirect", drawElementsIndirect);
        ASSIGN("glDrawTransformFeedback", drawTransformFeedback);
        ASSIGN("glDrawTransformFeedbackStream", drawTransformFeedbackStream);
        ASSIGN("glEndQueryIndexed", endQueryIndexed);
        ASSIGN("glGenTransformFeedbacks", genTransformFeedbacks);
        ASSIGN("glGetActiveSubroutineName", getActiveSubroutineName);
        ASSIGN("glGetActiveSubroutineUniformName", getActiveSubroutineUniformName);
        ASSIGN("glGetActiveSubroutineUniformiv", getActiveSubroutineUniformiv);
        ASSIGN("glGetProgramStageiv", getProgramStageiv);
        ASSIGN("glGetQueryIndexediv", getQueryIndexediv);
        ASSIGN("glGetSubroutineIndex", getSubroutineIndex);
        ASSIGN("glGetSubroutineUniformLocation", getSubroutineUniformLocation);
        ASSIGN("glGetUniformSubroutineuiv", getUniformSubroutineuiv);
        ASSIGN("glGetUniformdv", getUniformdv);
        ASSIGN("glIsTransformFeedback", isTransformFeedback);
        ASSIGN("glMinSampleShading", minSampleShading);
        ASSIGN("glPatchParameterfv", patchParameterfv);
        ASSIGN("glPatchParameteri", patchParameteri);
        ASSIGN("glPauseTransformFeedback", pauseTransformFeedback);
        ASSIGN("glResumeTransformFeedback", resumeTransformFeedback);
        ASSIGN("glUniform1d", uniform1d);
        ASSIGN("glUniform1dv", uniform1dv);
        ASSIGN("glUniform2d", uniform2d);
        ASSIGN("glUniform2dv", uniform2dv);
        ASSIGN("glUniform3d", uniform3d);
        ASSIGN("glUniform3dv", uniform3dv);
        ASSIGN("glUniform4d", uniform4d);
        ASSIGN("glUniform4dv", uniform4dv);
        ASSIGN("glUniformMatrix2dv", uniformMatrix2dv);
        ASSIGN("glUniformMatrix2x3dv", uniformMatrix2x3dv);
        ASSIGN("glUniformMatrix2x4dv", uniformMatrix2x4dv);
        ASSIGN("glUniformMatrix3dv", uniformMatrix3dv);
        ASSIGN("glUniformMatrix3x2dv", uniformMatrix3x2dv);
        ASSIGN("glUniformMatrix3x4dv", uniformMatrix3x4dv);
        ASSIGN("glUniformMatrix4dv", uniformMatrix4dv);
        ASSIGN("glUniformMatrix4x2dv", uniformMatrix4x2dv);
        ASSIGN("glUniformMatrix4x3dv", uniformMatrix4x3dv);
        ASSIGN("glUniformSubroutinesuiv", uniformSubroutinesuiv);
    }

    if (version >= gl::Version(4, 1))
    {
        ASSIGN("glActiveShaderProgram", activeShaderProgram);
        ASSIGN("glBindProgramPipeline", bindProgramPipeline);
        ASSIGN("glClearDepthf", clearDepthf);
        ASSIGN("glCreateShaderProgramv", createShaderProgramv);
        ASSIGN("glDeleteProgramPipelines", deleteProgramPipelines);
        ASSIGN("glDepthRangeArrayv", depthRangeArrayv);
        ASSIGN("glDepthRangeIndexed", depthRangeIndexed);
        ASSIGN("glDepthRangef", depthRangef);
        ASSIGN("glGenProgramPipelines", genProgramPipelines);
        ASSIGN("glGetDoublei_v", getDoublei_v);
        ASSIGN("glGetFloati_v", getFloati_v);
        ASSIGN("glGetProgramBinary", getProgramBinary);
        ASSIGN("glGetProgramPipelineInfoLog", getProgramPipelineInfoLog);
        ASSIGN("glGetProgramPipelineiv", getProgramPipelineiv);
        ASSIGN("glGetShaderPrecisionFormat", getShaderPrecisionFormat);
        ASSIGN("glGetVertexAttribLdv", getVertexAttribLdv);
        ASSIGN("glIsProgramPipeline", isProgramPipeline);
        ASSIGN("glProgramBinary", programBinary);
        ASSIGN("glProgramParameteri", programParameteri);
        ASSIGN("glProgramUniform1d", programUniform1d);
        ASSIGN("glProgramUniform1dv", programUniform1dv);
        ASSIGN("glProgramUniform1f", programUniform1f);
        ASSIGN("glProgramUniform1fv", programUniform1fv);
        ASSIGN("glProgramUniform1i", programUniform1i);
        ASSIGN("glProgramUniform1iv", programUniform1iv);
        ASSIGN("glProgramUniform1ui", programUniform1ui);
        ASSIGN("glProgramUniform1uiv", programUniform1uiv);
        ASSIGN("glProgramUniform2d", programUniform2d);
        ASSIGN("glProgramUniform2dv", programUniform2dv);
        ASSIGN("glProgramUniform2f", programUniform2f);
        ASSIGN("glProgramUniform2fv", programUniform2fv);
        ASSIGN("glProgramUniform2i", programUniform2i);
        ASSIGN("glProgramUniform2iv", programUniform2iv);
        ASSIGN("glProgramUniform2ui", programUniform2ui);
        ASSIGN("glProgramUniform2uiv", programUniform2uiv);
        ASSIGN("glProgramUniform3d", programUniform3d);
        ASSIGN("glProgramUniform3dv", programUniform3dv);
        ASSIGN("glProgramUniform3f", programUniform3f);
        ASSIGN("glProgramUniform3fv", programUniform3fv);
        ASSIGN("glProgramUniform3i", programUniform3i);
        ASSIGN("glProgramUniform3iv", programUniform3iv);
        ASSIGN("glProgramUniform3ui", programUniform3ui);
        ASSIGN("glProgramUniform3uiv", programUniform3uiv);
        ASSIGN("glProgramUniform4d", programUniform4d);
        ASSIGN("glProgramUniform4dv", programUniform4dv);
        ASSIGN("glProgramUniform4f", programUniform4f);
        ASSIGN("glProgramUniform4fv", programUniform4fv);
        ASSIGN("glProgramUniform4i", programUniform4i);
        ASSIGN("glProgramUniform4iv", programUniform4iv);
        ASSIGN("glProgramUniform4ui", programUniform4ui);
        ASSIGN("glProgramUniform4uiv", programUniform4uiv);
        ASSIGN("glProgramUniformMatrix2dv", programUniformMatrix2dv);
        ASSIGN("glProgramUniformMatrix2fv", programUniformMatrix2fv);
        ASSIGN("glProgramUniformMatrix2x3dv", programUniformMatrix2x3dv);
        ASSIGN("glProgramUniformMatrix2x3fv", programUniformMatrix2x3fv);
        ASSIGN("glProgramUniformMatrix2x4dv", programUniformMatrix2x4dv);
        ASSIGN("glProgramUniformMatrix2x4fv", programUniformMatrix2x4fv);
        ASSIGN("glProgramUniformMatrix3dv", programUniformMatrix3dv);
        ASSIGN("glProgramUniformMatrix3fv", programUniformMatrix3fv);
        ASSIGN("glProgramUniformMatrix3x2dv", programUniformMatrix3x2dv);
        ASSIGN("glProgramUniformMatrix3x2fv", programUniformMatrix3x2fv);
        ASSIGN("glProgramUniformMatrix3x4dv", programUniformMatrix3x4dv);
        ASSIGN("glProgramUniformMatrix3x4fv", programUniformMatrix3x4fv);
        ASSIGN("glProgramUniformMatrix4dv", programUniformMatrix4dv);
        ASSIGN("glProgramUniformMatrix4fv", programUniformMatrix4fv);
        ASSIGN("glProgramUniformMatrix4x2dv", programUniformMatrix4x2dv);
        ASSIGN("glProgramUniformMatrix4x2fv", programUniformMatrix4x2fv);
        ASSIGN("glProgramUniformMatrix4x3dv", programUniformMatrix4x3dv);
        ASSIGN("glProgramUniformMatrix4x3fv", programUniformMatrix4x3fv);
        ASSIGN("glReleaseShaderCompiler", releaseShaderCompiler);
        ASSIGN("glScissorArrayv", scissorArrayv);
        ASSIGN("glScissorIndexed", scissorIndexed);
        ASSIGN("glScissorIndexedv", scissorIndexedv);
        ASSIGN("glShaderBinary", shaderBinary);
        ASSIGN("glUseProgramStages", useProgramStages);
        ASSIGN("glValidateProgramPipeline", validateProgramPipeline);
        ASSIGN("glVertexAttribL1d", vertexAttribL1d);
        ASSIGN("glVertexAttribL1dv", vertexAttribL1dv);
        ASSIGN("glVertexAttribL2d", vertexAttribL2d);
        ASSIGN("glVertexAttribL2dv", vertexAttribL2dv);
        ASSIGN("glVertexAttribL3d", vertexAttribL3d);
        ASSIGN("glVertexAttribL3dv", vertexAttribL3dv);
        ASSIGN("glVertexAttribL4d", vertexAttribL4d);
        ASSIGN("glVertexAttribL4dv", vertexAttribL4dv);
        ASSIGN("glVertexAttribLPointer", vertexAttribLPointer);
        ASSIGN("glViewportArrayv", viewportArrayv);
        ASSIGN("glViewportIndexedf", viewportIndexedf);
        ASSIGN("glViewportIndexedfv", viewportIndexedfv);
    }

    if (version >= gl::Version(4, 2))
    {
        ASSIGN("glBindImageTexture", bindImageTexture);
        ASSIGN("glDrawArraysInstancedBaseInstance", drawArraysInstancedBaseInstance);
        ASSIGN("glDrawElementsInstancedBaseInstance", drawElementsInstancedBaseInstance);
        ASSIGN("glDrawElementsInstancedBaseVertexBaseInstance",
               drawElementsInstancedBaseVertexBaseInstance);
        ASSIGN("glDrawTransformFeedbackInstanced", drawTransformFeedbackInstanced);
        ASSIGN("glDrawTransformFeedbackStreamInstanced", drawTransformFeedbackStreamInstanced);
        ASSIGN("glGetActiveAtomicCounterBufferiv", getActiveAtomicCounterBufferiv);
        ASSIGN("glGetInternalformativ", getInternalformativ);
        ASSIGN("glMemoryBarrier", memoryBarrier);
        ASSIGN("glTexStorage1D", texStorage1D);
        ASSIGN("glTexStorage2D", texStorage2D);
        ASSIGN("glTexStorage3D", texStorage3D);
    }

    if (version >= gl::Version(4, 3))
    {
        ASSIGN("glBindVertexBuffer", bindVertexBuffer);
        ASSIGN("glClearBufferData", clearBufferData);
        ASSIGN("glClearBufferSubData", clearBufferSubData);
        ASSIGN("glCopyImageSubData", copyImageSubData);
        ASSIGN("glDebugMessageCallback", debugMessageCallback);
        ASSIGN("glDebugMessageControl", debugMessageControl);
        ASSIGN("glDebugMessageInsert", debugMessageInsert);
        ASSIGN("glDispatchCompute", dispatchCompute);
        ASSIGN("glDispatchComputeIndirect", dispatchComputeIndirect);
        ASSIGN("glFramebufferParameteri", framebufferParameteri);
        ASSIGN("glGetDebugMessageLog", getDebugMessageLog);
        ASSIGN("glGetFramebufferParameteriv", getFramebufferParameteriv);
        ASSIGN("glGetInternalformati64v", getInternalformati64v);
        ASSIGN("glGetObjectLabel", getObjectLabel);
        ASSIGN("glGetObjectPtrLabel", getObjectPtrLabel);
        ASSIGN("glGetPointerv", getPointerv);
        ASSIGN("glGetProgramInterfaceiv", getProgramInterfaceiv);
        ASSIGN("glGetProgramResourceIndex", getProgramResourceIndex);
        ASSIGN("glGetProgramResourceLocation", getProgramResourceLocation);
        ASSIGN("glGetProgramResourceLocationIndex", getProgramResourceLocationIndex);
        ASSIGN("glGetProgramResourceName", getProgramResourceName);
        ASSIGN("glGetProgramResourceiv", getProgramResourceiv);
        ASSIGN("glInvalidateBufferData", invalidateBufferData);
        ASSIGN("glInvalidateBufferSubData", invalidateBufferSubData);
        ASSIGN("glInvalidateFramebuffer", invalidateFramebuffer);
        ASSIGN("glInvalidateSubFramebuffer", invalidateSubFramebuffer);
        ASSIGN("glInvalidateTexImage", invalidateTexImage);
        ASSIGN("glInvalidateTexSubImage", invalidateTexSubImage);
        ASSIGN("glMultiDrawArraysIndirect", multiDrawArraysIndirect);
        ASSIGN("glMultiDrawElementsIndirect", multiDrawElementsIndirect);
        ASSIGN("glObjectLabel", objectLabel);
        ASSIGN("glObjectPtrLabel", objectPtrLabel);
        ASSIGN("glPopDebugGroup", popDebugGroup);
        ASSIGN("glPushDebugGroup", pushDebugGroup);
        ASSIGN("glShaderStorageBlockBinding", shaderStorageBlockBinding);
        ASSIGN("glTexBufferRange", texBufferRange);
        ASSIGN("glTexStorage2DMultisample", texStorage2DMultisample);
        ASSIGN("glTexStorage3DMultisample", texStorage3DMultisample);
        ASSIGN("glTextureView", textureView);
        ASSIGN("glVertexAttribBinding", vertexAttribBinding);
        ASSIGN("glVertexAttribFormat", vertexAttribFormat);
        ASSIGN("glVertexAttribIFormat", vertexAttribIFormat);
        ASSIGN("glVertexAttribLFormat", vertexAttribLFormat);
        ASSIGN("glVertexBindingDivisor", vertexBindingDivisor);
    }

    if (version >= gl::Version(4, 4))
    {
        ASSIGN("glBindBuffersBase", bindBuffersBase);
        ASSIGN("glBindBuffersRange", bindBuffersRange);
        ASSIGN("glBindImageTextures", bindImageTextures);
        ASSIGN("glBindSamplers", bindSamplers);
        ASSIGN("glBindTextures", bindTextures);
        ASSIGN("glBindVertexBuffers", bindVertexBuffers);
        ASSIGN("glBufferStorage", bufferStorage);
        ASSIGN("glClearTexImage", clearTexImage);
        ASSIGN("glClearTexSubImage", clearTexSubImage);
    }

    if (version >= gl::Version(4, 5))
    {
        ASSIGN("glBindTextureUnit", bindTextureUnit);
        ASSIGN("glBlitNamedFramebuffer", blitNamedFramebuffer);
        ASSIGN("glCheckNamedFramebufferStatus", checkNamedFramebufferStatus);
        ASSIGN("glClearNamedBufferData", clearNamedBufferData);
        ASSIGN("glClearNamedBufferSubData", clearNamedBufferSubData);
        ASSIGN("glClearNamedFramebufferfi", clearNamedFramebufferfi);
        ASSIGN("glClearNamedFramebufferfv", clearNamedFramebufferfv);
        ASSIGN("glClearNamedFramebufferiv", clearNamedFramebufferiv);
        ASSIGN("glClearNamedFramebufferuiv", clearNamedFramebufferuiv);
        ASSIGN("glClipControl", clipControl);
        ASSIGN("glCompressedTextureSubImage1D", compressedTextureSubImage1D);
        ASSIGN("glCompressedTextureSubImage2D", compressedTextureSubImage2D);
        ASSIGN("glCompressedTextureSubImage3D", compressedTextureSubImage3D);
        ASSIGN("glCopyNamedBufferSubData", copyNamedBufferSubData);
        ASSIGN("glCopyTextureSubImage1D", copyTextureSubImage1D);
        ASSIGN("glCopyTextureSubImage2D", copyTextureSubImage2D);
        ASSIGN("glCopyTextureSubImage3D", copyTextureSubImage3D);
        ASSIGN("glCreateBuffers", createBuffers);
        ASSIGN("glCreateFramebuffers", createFramebuffers);
        ASSIGN("glCreateProgramPipelines", createProgramPipelines);
        ASSIGN("glCreateQueries", createQueries);
        ASSIGN("glCreateRenderbuffers", createRenderbuffers);
        ASSIGN("glCreateSamplers", createSamplers);
        ASSIGN("glCreateTextures", createTextures);
        ASSIGN("glCreateTransformFeedbacks", createTransformFeedbacks);
        ASSIGN("glCreateVertexArrays", createVertexArrays);
        ASSIGN("glDisableVertexArrayAttrib", disableVertexArrayAttrib);
        ASSIGN("glEnableVertexArrayAttrib", enableVertexArrayAttrib);
        ASSIGN("glFlushMappedNamedBufferRange", flushMappedNamedBufferRange);
        ASSIGN("glGenerateTextureMipmap", generateTextureMipmap);
        ASSIGN("glGetCompressedTextureImage", getCompressedTextureImage);
        ASSIGN("glGetCompressedTextureSubImage", getCompressedTextureSubImage);
        ASSIGN("glGetGraphicsResetStatus", getGraphicsResetStatus);
        ASSIGN("glGetNamedBufferParameteri64v", getNamedBufferParameteri64v);
        ASSIGN("glGetNamedBufferParameteriv", getNamedBufferParameteriv);
        ASSIGN("glGetNamedBufferPointerv", getNamedBufferPointerv);
        ASSIGN("glGetNamedBufferSubData", getNamedBufferSubData);
        ASSIGN("glGetNamedFramebufferAttachmentParameteriv",
               getNamedFramebufferAttachmentParameteriv);
        ASSIGN("glGetNamedFramebufferParameteriv", getNamedFramebufferParameteriv);
        ASSIGN("glGetNamedRenderbufferParameteriv", getNamedRenderbufferParameteriv);
        ASSIGN("glGetQueryBufferObjecti64v", getQueryBufferObjecti64v);
        ASSIGN("glGetQueryBufferObjectiv", getQueryBufferObjectiv);
        ASSIGN("glGetQueryBufferObjectui64v", getQueryBufferObjectui64v);
        ASSIGN("glGetQueryBufferObjectuiv", getQueryBufferObjectuiv);
        ASSIGN("glGetTextureImage", getTextureImage);
        ASSIGN("glGetTextureLevelParameterfv", getTextureLevelParameterfv);
        ASSIGN("glGetTextureLevelParameteriv", getTextureLevelParameteriv);
        ASSIGN("glGetTextureParameterIiv", getTextureParameterIiv);
        ASSIGN("glGetTextureParameterIuiv", getTextureParameterIuiv);
        ASSIGN("glGetTextureParameterfv", getTextureParameterfv);
        ASSIGN("glGetTextureParameteriv", getTextureParameteriv);
        ASSIGN("glGetTextureSubImage", getTextureSubImage);
        ASSIGN("glGetTransformFeedbacki64_v", getTransformFeedbacki64_v);
        ASSIGN("glGetTransformFeedbacki_v", getTransformFeedbacki_v);
        ASSIGN("glGetTransformFeedbackiv", getTransformFeedbackiv);
        ASSIGN("glGetVertexArrayIndexed64iv", getVertexArrayIndexed64iv);
        ASSIGN("glGetVertexArrayIndexediv", getVertexArrayIndexediv);
        ASSIGN("glGetVertexArrayiv", getVertexArrayiv);
        ASSIGN("glGetnCompressedTexImage", getnCompressedTexImage);
        ASSIGN("glGetnTexImage", getnTexImage);
        ASSIGN("glGetnUniformdv", getnUniformdv);
        ASSIGN("glGetnUniformfv", getnUniformfv);
        ASSIGN("glGetnUniformiv", getnUniformiv);
        ASSIGN("glGetnUniformuiv", getnUniformuiv);
        ASSIGN("glInvalidateNamedFramebufferData", invalidateNamedFramebufferData);
        ASSIGN("glInvalidateNamedFramebufferSubData", invalidateNamedFramebufferSubData);
        ASSIGN("glMapNamedBuffer", mapNamedBuffer);
        ASSIGN("glMapNamedBufferRange", mapNamedBufferRange);
        ASSIGN("glMemoryBarrierByRegion", memoryBarrierByRegion);
        ASSIGN("glNamedBufferData", namedBufferData);
        ASSIGN("glNamedBufferStorage", namedBufferStorage);
        ASSIGN("glNamedBufferSubData", namedBufferSubData);
        ASSIGN("glNamedFramebufferDrawBuffer", namedFramebufferDrawBuffer);
        ASSIGN("glNamedFramebufferDrawBuffers", namedFramebufferDrawBuffers);
        ASSIGN("glNamedFramebufferParameteri", namedFramebufferParameteri);
        ASSIGN("glNamedFramebufferReadBuffer", namedFramebufferReadBuffer);
        ASSIGN("glNamedFramebufferRenderbuffer", namedFramebufferRenderbuffer);
        ASSIGN("glNamedFramebufferTexture", namedFramebufferTexture);
        ASSIGN("glNamedFramebufferTextureLayer", namedFramebufferTextureLayer);
        ASSIGN("glNamedRenderbufferStorage", namedRenderbufferStorage);
        ASSIGN("glNamedRenderbufferStorageMultisample", namedRenderbufferStorageMultisample);
        ASSIGN("glReadnPixels", readnPixels);
        ASSIGN("glTextureBarrier", textureBarrier);
        ASSIGN("glTextureBuffer", textureBuffer);
        ASSIGN("glTextureBufferRange", textureBufferRange);
        ASSIGN("glTextureParameterIiv", textureParameterIiv);
        ASSIGN("glTextureParameterIuiv", textureParameterIuiv);
        ASSIGN("glTextureParameterf", textureParameterf);
        ASSIGN("glTextureParameterfv", textureParameterfv);
        ASSIGN("glTextureParameteri", textureParameteri);
        ASSIGN("glTextureParameteriv", textureParameteriv);
        ASSIGN("glTextureStorage1D", textureStorage1D);
        ASSIGN("glTextureStorage2D", textureStorage2D);
        ASSIGN("glTextureStorage2DMultisample", textureStorage2DMultisample);
        ASSIGN("glTextureStorage3D", textureStorage3D);
        ASSIGN("glTextureStorage3DMultisample", textureStorage3DMultisample);
        ASSIGN("glTextureSubImage1D", textureSubImage1D);
        ASSIGN("glTextureSubImage2D", textureSubImage2D);
        ASSIGN("glTextureSubImage3D", textureSubImage3D);
        ASSIGN("glTransformFeedbackBufferBase", transformFeedbackBufferBase);
        ASSIGN("glTransformFeedbackBufferRange", transformFeedbackBufferRange);
        ASSIGN("glUnmapNamedBuffer", unmapNamedBuffer);
        ASSIGN("glVertexArrayAttribBinding", vertexArrayAttribBinding);
        ASSIGN("glVertexArrayAttribFormat", vertexArrayAttribFormat);
        ASSIGN("glVertexArrayAttribIFormat", vertexArrayAttribIFormat);
        ASSIGN("glVertexArrayAttribLFormat", vertexArrayAttribLFormat);
        ASSIGN("glVertexArrayBindingDivisor", vertexArrayBindingDivisor);
        ASSIGN("glVertexArrayElementBuffer", vertexArrayElementBuffer);
        ASSIGN("glVertexArrayVertexBuffer", vertexArrayVertexBuffer);
        ASSIGN("glVertexArrayVertexBuffers", vertexArrayVertexBuffers);
    }

    if (extensions.count("GL_ARB_ES2_compatibility") != 0)
    {
        ASSIGN("glClearDepthf", clearDepthf);
        ASSIGN("glDepthRangef", depthRangef);
        ASSIGN("glGetShaderPrecisionFormat", getShaderPrecisionFormat);
        ASSIGN("glReleaseShaderCompiler", releaseShaderCompiler);
        ASSIGN("glShaderBinary", shaderBinary);
    }

    if (extensions.count("GL_ARB_ES3_1_compatibility") != 0)
    {
        ASSIGN("glMemoryBarrierByRegion", memoryBarrierByRegion);
    }

    if (extensions.count("GL_ARB_ES3_2_compatibility") != 0)
    {
        ASSIGN("glPrimitiveBoundingBoxARB", primitiveBoundingBox);
    }

    if (extensions.count("GL_ARB_base_instance") != 0)
    {
        ASSIGN("glDrawArraysInstancedBaseInstance", drawArraysInstancedBaseInstance);
        ASSIGN("glDrawElementsInstancedBaseInstance", drawElementsInstancedBaseInstance);
        ASSIGN("glDrawElementsInstancedBaseVertexBaseInstance",
               drawElementsInstancedBaseVertexBaseInstance);
    }

    if (extensions.count("GL_ARB_blend_func_extended") != 0)
    {
        ASSIGN("glBindFragDataLocationIndexed", bindFragDataLocationIndexed);
        ASSIGN("glGetFragDataIndex", getFragDataIndex);
    }

    if (extensions.count("GL_ARB_buffer_storage") != 0)
    {
        ASSIGN("glBufferStorage", bufferStorage);
    }

    if (extensions.count("GL_ARB_clear_buffer_object") != 0)
    {
        ASSIGN("glClearBufferData", clearBufferData);
        ASSIGN("glClearBufferSubData", clearBufferSubData);
    }

    if (extensions.count("GL_ARB_clear_texture") != 0)
    {
        ASSIGN("glClearTexImage", clearTexImage);
        ASSIGN("glClearTexSubImage", clearTexSubImage);
    }

    if (extensions.count("GL_ARB_clip_control") != 0)
    {
        ASSIGN("glClipControl", clipControl);
    }

    if (extensions.count("GL_ARB_color_buffer_float") != 0)
    {
        ASSIGN("glClampColorARB", clampColor);
    }

    if (extensions.count("GL_ARB_compute_shader") != 0)
    {
        ASSIGN("glDispatchCompute", dispatchCompute);
        ASSIGN("glDispatchComputeIndirect", dispatchComputeIndirect);
    }

    if (extensions.count("GL_ARB_copy_buffer") != 0)
    {
        ASSIGN("glCopyBufferSubData", copyBufferSubData);
    }

    if (extensions.count("GL_ARB_copy_image") != 0)
    {
        ASSIGN("glCopyImageSubData", copyImageSubData);
    }

    if (extensions.count("GL_ARB_debug_output") != 0)
    {
        ASSIGN("glDebugMessageCallbackARB", debugMessageCallback);
        ASSIGN("glDebugMessageControlARB", debugMessageControl);
        ASSIGN("glDebugMessageInsertARB", debugMessageInsert);
        ASSIGN("glGetDebugMessageLogARB", getDebugMessageLog);
    }

    if (extensions.count("GL_ARB_direct_state_access") != 0)
    {
        ASSIGN("glBindTextureUnit", bindTextureUnit);
        ASSIGN("glBlitNamedFramebuffer", blitNamedFramebuffer);
        ASSIGN("glCheckNamedFramebufferStatus", checkNamedFramebufferStatus);
        ASSIGN("glClearNamedBufferData", clearNamedBufferData);
        ASSIGN("glClearNamedBufferSubData", clearNamedBufferSubData);
        ASSIGN("glClearNamedFramebufferfi", clearNamedFramebufferfi);
        ASSIGN("glClearNamedFramebufferfv", clearNamedFramebufferfv);
        ASSIGN("glClearNamedFramebufferiv", clearNamedFramebufferiv);
        ASSIGN("glClearNamedFramebufferuiv", clearNamedFramebufferuiv);
        ASSIGN("glCompressedTextureSubImage1D", compressedTextureSubImage1D);
        ASSIGN("glCompressedTextureSubImage2D", compressedTextureSubImage2D);
        ASSIGN("glCompressedTextureSubImage3D", compressedTextureSubImage3D);
        ASSIGN("glCopyNamedBufferSubData", copyNamedBufferSubData);
        ASSIGN("glCopyTextureSubImage1D", copyTextureSubImage1D);
        ASSIGN("glCopyTextureSubImage2D", copyTextureSubImage2D);
        ASSIGN("glCopyTextureSubImage3D", copyTextureSubImage3D);
        ASSIGN("glCreateBuffers", createBuffers);
        ASSIGN("glCreateFramebuffers", createFramebuffers);
        ASSIGN("glCreateProgramPipelines", createProgramPipelines);
        ASSIGN("glCreateQueries", createQueries);
        ASSIGN("glCreateRenderbuffers", createRenderbuffers);
        ASSIGN("glCreateSamplers", createSamplers);
        ASSIGN("glCreateTextures", createTextures);
        ASSIGN("glCreateTransformFeedbacks", createTransformFeedbacks);
        ASSIGN("glCreateVertexArrays", createVertexArrays);
        ASSIGN("glDisableVertexArrayAttrib", disableVertexArrayAttrib);
        ASSIGN("glEnableVertexArrayAttrib", enableVertexArrayAttrib);
        ASSIGN("glFlushMappedNamedBufferRange", flushMappedNamedBufferRange);
        ASSIGN("glGenerateTextureMipmap", generateTextureMipmap);
        ASSIGN("glGetCompressedTextureImage", getCompressedTextureImage);
        ASSIGN("glGetNamedBufferParameteri64v", getNamedBufferParameteri64v);
        ASSIGN("glGetNamedBufferParameteriv", getNamedBufferParameteriv);
        ASSIGN("glGetNamedBufferPointerv", getNamedBufferPointerv);
        ASSIGN("glGetNamedBufferSubData", getNamedBufferSubData);
        ASSIGN("glGetNamedFramebufferAttachmentParameteriv",
               getNamedFramebufferAttachmentParameteriv);
        ASSIGN("glGetNamedFramebufferParameteriv", getNamedFramebufferParameteriv);
        ASSIGN("glGetNamedRenderbufferParameteriv", getNamedRenderbufferParameteriv);
        ASSIGN("glGetQueryBufferObjecti64v", getQueryBufferObjecti64v);
        ASSIGN("glGetQueryBufferObjectiv", getQueryBufferObjectiv);
        ASSIGN("glGetQueryBufferObjectui64v", getQueryBufferObjectui64v);
        ASSIGN("glGetQueryBufferObjectuiv", getQueryBufferObjectuiv);
        ASSIGN("glGetTextureImage", getTextureImage);
        ASSIGN("glGetTextureLevelParameterfv", getTextureLevelParameterfv);
        ASSIGN("glGetTextureLevelParameteriv", getTextureLevelParameteriv);
        ASSIGN("glGetTextureParameterIiv", getTextureParameterIiv);
        ASSIGN("glGetTextureParameterIuiv", getTextureParameterIuiv);
        ASSIGN("glGetTextureParameterfv", getTextureParameterfv);
        ASSIGN("glGetTextureParameteriv", getTextureParameteriv);
        ASSIGN("glGetTransformFeedbacki64_v", getTransformFeedbacki64_v);
        ASSIGN("glGetTransformFeedbacki_v", getTransformFeedbacki_v);
        ASSIGN("glGetTransformFeedbackiv", getTransformFeedbackiv);
        ASSIGN("glGetVertexArrayIndexed64iv", getVertexArrayIndexed64iv);
        ASSIGN("glGetVertexArrayIndexediv", getVertexArrayIndexediv);
        ASSIGN("glGetVertexArrayiv", getVertexArrayiv);
        ASSIGN("glInvalidateNamedFramebufferData", invalidateNamedFramebufferData);
        ASSIGN("glInvalidateNamedFramebufferSubData", invalidateNamedFramebufferSubData);
        ASSIGN("glMapNamedBuffer", mapNamedBuffer);
        ASSIGN("glMapNamedBufferRange", mapNamedBufferRange);
        ASSIGN("glNamedBufferData", namedBufferData);
        ASSIGN("glNamedBufferStorage", namedBufferStorage);
        ASSIGN("glNamedBufferSubData", namedBufferSubData);
        ASSIGN("glNamedFramebufferDrawBuffer", namedFramebufferDrawBuffer);
        ASSIGN("glNamedFramebufferDrawBuffers", namedFramebufferDrawBuffers);
        ASSIGN("glNamedFramebufferParameteri", namedFramebufferParameteri);
        ASSIGN("glNamedFramebufferReadBuffer", namedFramebufferReadBuffer);
        ASSIGN("glNamedFramebufferRenderbuffer", namedFramebufferRenderbuffer);
        ASSIGN("glNamedFramebufferTexture", namedFramebufferTexture);
        ASSIGN("glNamedFramebufferTextureLayer", namedFramebufferTextureLayer);
        ASSIGN("glNamedRenderbufferStorage", namedRenderbufferStorage);
        ASSIGN("glNamedRenderbufferStorageMultisample", namedRenderbufferStorageMultisample);
        ASSIGN("glTextureBuffer", textureBuffer);
        ASSIGN("glTextureBufferRange", textureBufferRange);
        ASSIGN("glTextureParameterIiv", textureParameterIiv);
        ASSIGN("glTextureParameterIuiv", textureParameterIuiv);
        ASSIGN("glTextureParameterf", textureParameterf);
        ASSIGN("glTextureParameterfv", textureParameterfv);
        ASSIGN("glTextureParameteri", textureParameteri);
        ASSIGN("glTextureParameteriv", textureParameteriv);
        ASSIGN("glTextureStorage1D", textureStorage1D);
        ASSIGN("glTextureStorage2D", textureStorage2D);
        ASSIGN("glTextureStorage2DMultisample", textureStorage2DMultisample);
        ASSIGN("glTextureStorage3D", textureStorage3D);
        ASSIGN("glTextureStorage3DMultisample", textureStorage3DMultisample);
        ASSIGN("glTextureSubImage1D", textureSubImage1D);
        ASSIGN("glTextureSubImage2D", textureSubImage2D);
        ASSIGN("glTextureSubImage3D", textureSubImage3D);
        ASSIGN("glTransformFeedbackBufferBase", transformFeedbackBufferBase);
        ASSIGN("glTransformFeedbackBufferRange", transformFeedbackBufferRange);
        ASSIGN("glUnmapNamedBuffer", unmapNamedBuffer);
        ASSIGN("glVertexArrayAttribBinding", vertexArrayAttribBinding);
        ASSIGN("glVertexArrayAttribFormat", vertexArrayAttribFormat);
        ASSIGN("glVertexArrayAttribIFormat", vertexArrayAttribIFormat);
        ASSIGN("glVertexArrayAttribLFormat", vertexArrayAttribLFormat);
        ASSIGN("glVertexArrayBindingDivisor", vertexArrayBindingDivisor);
        ASSIGN("glVertexArrayElementBuffer", vertexArrayElementBuffer);
        ASSIGN("glVertexArrayVertexBuffer", vertexArrayVertexBuffer);
        ASSIGN("glVertexArrayVertexBuffers", vertexArrayVertexBuffers);
    }

    if (extensions.count("GL_ARB_draw_buffers") != 0)
    {
        ASSIGN("glDrawBuffersARB", drawBuffers);
    }

    if (extensions.count("GL_ARB_draw_buffers_blend") != 0)
    {
        ASSIGN("glBlendEquationSeparateiARB", blendEquationSeparatei);
        ASSIGN("glBlendEquationiARB", blendEquationi);
        ASSIGN("glBlendFuncSeparateiARB", blendFuncSeparatei);
        ASSIGN("glBlendFunciARB", blendFunci);
    }

    if (extensions.count("GL_ARB_draw_elements_base_vertex") != 0)
    {
        ASSIGN("glDrawElementsBaseVertex", drawElementsBaseVertex);
        ASSIGN("glDrawElementsInstancedBaseVertex", drawElementsInstancedBaseVertex);
        ASSIGN("glDrawRangeElementsBaseVertex", drawRangeElementsBaseVertex);
        ASSIGN("glMultiDrawElementsBaseVertex", multiDrawElementsBaseVertex);
    }

    if (extensions.count("GL_ARB_draw_indirect") != 0)
    {
        ASSIGN("glDrawArraysIndirect", drawArraysIndirect);
        ASSIGN("glDrawElementsIndirect", drawElementsIndirect);
    }

    if (extensions.count("GL_ARB_draw_instanced") != 0)
    {
        ASSIGN("glDrawArraysInstancedARB", drawArraysInstanced);
        ASSIGN("glDrawElementsInstancedARB", drawElementsInstanced);
    }

    if (extensions.count("GL_ARB_fragment_program") != 0)
    {
        ASSIGN("glGetProgramivARB", getProgramiv);
        ASSIGN("glIsProgramARB", isProgram);
    }

    if (extensions.count("GL_ARB_framebuffer_no_attachments") != 0)
    {
        ASSIGN("glFramebufferParameteri", framebufferParameteri);
        ASSIGN("glGetFramebufferParameteriv", getFramebufferParameteriv);
    }

    if (extensions.count("GL_ARB_framebuffer_object") != 0)
    {
        ASSIGN("glBindFramebuffer", bindFramebuffer);
        ASSIGN("glBindRenderbuffer", bindRenderbuffer);
        ASSIGN("glBlitFramebuffer", blitFramebuffer);
        ASSIGN("glCheckFramebufferStatus", checkFramebufferStatus);
        ASSIGN("glDeleteFramebuffers", deleteFramebuffers);
        ASSIGN("glDeleteRenderbuffers", deleteRenderbuffers);
        ASSIGN("glFramebufferRenderbuffer", framebufferRenderbuffer);
        ASSIGN("glFramebufferTexture1D", framebufferTexture1D);
        ASSIGN("glFramebufferTexture2D", framebufferTexture2D);
        ASSIGN("glFramebufferTexture3D", framebufferTexture3D);
        ASSIGN("glFramebufferTextureLayer", framebufferTextureLayer);
        ASSIGN("glGenFramebuffers", genFramebuffers);
        ASSIGN("glGenRenderbuffers", genRenderbuffers);
        ASSIGN("glGenerateMipmap", generateMipmap);
        ASSIGN("glGetFramebufferAttachmentParameteriv", getFramebufferAttachmentParameteriv);
        ASSIGN("glGetRenderbufferParameteriv", getRenderbufferParameteriv);
        ASSIGN("glIsFramebuffer", isFramebuffer);
        ASSIGN("glIsRenderbuffer", isRenderbuffer);
        ASSIGN("glRenderbufferStorage", renderbufferStorage);
        ASSIGN("glRenderbufferStorageMultisample", renderbufferStorageMultisample);
    }

    if (extensions.count("GL_ARB_geometry_shader4") != 0)
    {
        ASSIGN("glFramebufferTextureARB", framebufferTexture);
        ASSIGN("glFramebufferTextureLayerARB", framebufferTextureLayer);
        ASSIGN("glProgramParameteriARB", programParameteri);
    }

    if (extensions.count("GL_ARB_get_program_binary") != 0)
    {
        ASSIGN("glGetProgramBinary", getProgramBinary);
        ASSIGN("glProgramBinary", programBinary);
        ASSIGN("glProgramParameteri", programParameteri);
    }

    if (extensions.count("GL_ARB_get_texture_sub_image") != 0)
    {
        ASSIGN("glGetCompressedTextureSubImage", getCompressedTextureSubImage);
        ASSIGN("glGetTextureSubImage", getTextureSubImage);
    }

    if (extensions.count("GL_ARB_gpu_shader_fp64") != 0)
    {
        ASSIGN("glGetUniformdv", getUniformdv);
        ASSIGN("glUniform1d", uniform1d);
        ASSIGN("glUniform1dv", uniform1dv);
        ASSIGN("glUniform2d", uniform2d);
        ASSIGN("glUniform2dv", uniform2dv);
        ASSIGN("glUniform3d", uniform3d);
        ASSIGN("glUniform3dv", uniform3dv);
        ASSIGN("glUniform4d", uniform4d);
        ASSIGN("glUniform4dv", uniform4dv);
        ASSIGN("glUniformMatrix2dv", uniformMatrix2dv);
        ASSIGN("glUniformMatrix2x3dv", uniformMatrix2x3dv);
        ASSIGN("glUniformMatrix2x4dv", uniformMatrix2x4dv);
        ASSIGN("glUniformMatrix3dv", uniformMatrix3dv);
        ASSIGN("glUniformMatrix3x2dv", uniformMatrix3x2dv);
        ASSIGN("glUniformMatrix3x4dv", uniformMatrix3x4dv);
        ASSIGN("glUniformMatrix4dv", uniformMatrix4dv);
        ASSIGN("glUniformMatrix4x2dv", uniformMatrix4x2dv);
        ASSIGN("glUniformMatrix4x3dv", uniformMatrix4x3dv);
    }

    if (extensions.count("GL_ARB_imaging") != 0)
    {
        ASSIGN("glBlendColor", blendColor);
        ASSIGN("glBlendEquation", blendEquation);
    }

    if (extensions.count("GL_ARB_instanced_arrays") != 0)
    {
        ASSIGN("glVertexAttribDivisorARB", vertexAttribDivisor);
    }

    if (extensions.count("GL_ARB_internalformat_query") != 0)
    {
        ASSIGN("glGetInternalformativ", getInternalformativ);
    }

    if (extensions.count("GL_ARB_internalformat_query2") != 0)
    {
        ASSIGN("glGetInternalformati64v", getInternalformati64v);
    }

    if (extensions.count("GL_ARB_invalidate_subdata") != 0)
    {
        ASSIGN("glInvalidateBufferData", invalidateBufferData);
        ASSIGN("glInvalidateBufferSubData", invalidateBufferSubData);
        ASSIGN("glInvalidateFramebuffer", invalidateFramebuffer);
        ASSIGN("glInvalidateSubFramebuffer", invalidateSubFramebuffer);
        ASSIGN("glInvalidateTexImage", invalidateTexImage);
        ASSIGN("glInvalidateTexSubImage", invalidateTexSubImage);
    }

    if (extensions.count("GL_ARB_map_buffer_range") != 0)
    {
        ASSIGN("glFlushMappedBufferRange", flushMappedBufferRange);
        ASSIGN("glMapBufferRange", mapBufferRange);
    }

    if (extensions.count("GL_ARB_multi_bind") != 0)
    {
        ASSIGN("glBindBuffersBase", bindBuffersBase);
        ASSIGN("glBindBuffersRange", bindBuffersRange);
        ASSIGN("glBindImageTextures", bindImageTextures);
        ASSIGN("glBindSamplers", bindSamplers);
        ASSIGN("glBindTextures", bindTextures);
        ASSIGN("glBindVertexBuffers", bindVertexBuffers);
    }

    if (extensions.count("GL_ARB_multi_draw_indirect") != 0)
    {
        ASSIGN("glMultiDrawArraysIndirect", multiDrawArraysIndirect);
        ASSIGN("glMultiDrawElementsIndirect", multiDrawElementsIndirect);
    }

    if (extensions.count("GL_ARB_multisample") != 0)
    {
        ASSIGN("glSampleCoverageARB", sampleCoverage);
    }

    if (extensions.count("GL_ARB_multitexture") != 0)
    {
        ASSIGN("glActiveTextureARB", activeTexture);
    }

    if (extensions.count("GL_ARB_occlusion_query") != 0)
    {
        ASSIGN("glBeginQueryARB", beginQuery);
        ASSIGN("glDeleteQueriesARB", deleteQueries);
        ASSIGN("glEndQueryARB", endQuery);
        ASSIGN("glGenQueriesARB", genQueries);
        ASSIGN("glGetQueryObjectivARB", getQueryObjectiv);
        ASSIGN("glGetQueryObjectuivARB", getQueryObjectuiv);
        ASSIGN("glGetQueryivARB", getQueryiv);
        ASSIGN("glIsQueryARB", isQuery);
    }

    if (extensions.count("GL_ARB_parallel_shader_compile") != 0)
    {
        ASSIGN("glMaxShaderCompilerThreadsARB", maxShaderCompilerThreadsARB);
    }

    if (extensions.count("GL_ARB_point_parameters") != 0)
    {
        ASSIGN("glPointParameterfARB", pointParameterf);
        ASSIGN("glPointParameterfvARB", pointParameterfv);
    }

    if (extensions.count("GL_ARB_program_interface_query") != 0)
    {
        ASSIGN("glGetProgramInterfaceiv", getProgramInterfaceiv);
        ASSIGN("glGetProgramResourceIndex", getProgramResourceIndex);
        ASSIGN("glGetProgramResourceLocation", getProgramResourceLocation);
        ASSIGN("glGetProgramResourceLocationIndex", getProgramResourceLocationIndex);
        ASSIGN("glGetProgramResourceName", getProgramResourceName);
        ASSIGN("glGetProgramResourceiv", getProgramResourceiv);
    }

    if (extensions.count("GL_ARB_provoking_vertex") != 0)
    {
        ASSIGN("glProvokingVertex", provokingVertex);
    }

    if (extensions.count("GL_ARB_robustness") != 0)
    {
        ASSIGN("glGetGraphicsResetStatusARB", getGraphicsResetStatus);
        ASSIGN("glGetnCompressedTexImageARB", getnCompressedTexImage);
        ASSIGN("glGetnTexImageARB", getnTexImage);
        ASSIGN("glGetnUniformdvARB", getnUniformdv);
        ASSIGN("glGetnUniformfvARB", getnUniformfv);
        ASSIGN("glGetnUniformivARB", getnUniformiv);
        ASSIGN("glGetnUniformuivARB", getnUniformuiv);
        ASSIGN("glReadnPixelsARB", readnPixels);
    }

    if (extensions.count("GL_ARB_sample_shading") != 0)
    {
        ASSIGN("glMinSampleShadingARB", minSampleShading);
    }

    if (extensions.count("GL_ARB_sampler_objects") != 0)
    {
        ASSIGN("glBindSampler", bindSampler);
        ASSIGN("glDeleteSamplers", deleteSamplers);
        ASSIGN("glGenSamplers", genSamplers);
        ASSIGN("glGetSamplerParameterIiv", getSamplerParameterIiv);
        ASSIGN("glGetSamplerParameterIuiv", getSamplerParameterIuiv);
        ASSIGN("glGetSamplerParameterfv", getSamplerParameterfv);
        ASSIGN("glGetSamplerParameteriv", getSamplerParameteriv);
        ASSIGN("glIsSampler", isSampler);
        ASSIGN("glSamplerParameterIiv", samplerParameterIiv);
        ASSIGN("glSamplerParameterIuiv", samplerParameterIuiv);
        ASSIGN("glSamplerParameterf", samplerParameterf);
        ASSIGN("glSamplerParameterfv", samplerParameterfv);
        ASSIGN("glSamplerParameteri", samplerParameteri);
        ASSIGN("glSamplerParameteriv", samplerParameteriv);
    }

    if (extensions.count("GL_ARB_separate_shader_objects") != 0)
    {
        ASSIGN("glActiveShaderProgram", activeShaderProgram);
        ASSIGN("glBindProgramPipeline", bindProgramPipeline);
        ASSIGN("glCreateShaderProgramv", createShaderProgramv);
        ASSIGN("glDeleteProgramPipelines", deleteProgramPipelines);
        ASSIGN("glGenProgramPipelines", genProgramPipelines);
        ASSIGN("glGetProgramPipelineInfoLog", getProgramPipelineInfoLog);
        ASSIGN("glGetProgramPipelineiv", getProgramPipelineiv);
        ASSIGN("glIsProgramPipeline", isProgramPipeline);
        ASSIGN("glProgramParameteri", programParameteri);
        ASSIGN("glProgramUniform1d", programUniform1d);
        ASSIGN("glProgramUniform1dv", programUniform1dv);
        ASSIGN("glProgramUniform1f", programUniform1f);
        ASSIGN("glProgramUniform1fv", programUniform1fv);
        ASSIGN("glProgramUniform1i", programUniform1i);
        ASSIGN("glProgramUniform1iv", programUniform1iv);
        ASSIGN("glProgramUniform1ui", programUniform1ui);
        ASSIGN("glProgramUniform1uiv", programUniform1uiv);
        ASSIGN("glProgramUniform2d", programUniform2d);
        ASSIGN("glProgramUniform2dv", programUniform2dv);
        ASSIGN("glProgramUniform2f", programUniform2f);
        ASSIGN("glProgramUniform2fv", programUniform2fv);
        ASSIGN("glProgramUniform2i", programUniform2i);
        ASSIGN("glProgramUniform2iv", programUniform2iv);
        ASSIGN("glProgramUniform2ui", programUniform2ui);
        ASSIGN("glProgramUniform2uiv", programUniform2uiv);
        ASSIGN("glProgramUniform3d", programUniform3d);
        ASSIGN("glProgramUniform3dv", programUniform3dv);
        ASSIGN("glProgramUniform3f", programUniform3f);
        ASSIGN("glProgramUniform3fv", programUniform3fv);
        ASSIGN("glProgramUniform3i", programUniform3i);
        ASSIGN("glProgramUniform3iv", programUniform3iv);
        ASSIGN("glProgramUniform3ui", programUniform3ui);
        ASSIGN("glProgramUniform3uiv", programUniform3uiv);
        ASSIGN("glProgramUniform4d", programUniform4d);
        ASSIGN("glProgramUniform4dv", programUniform4dv);
        ASSIGN("glProgramUniform4f", programUniform4f);
        ASSIGN("glProgramUniform4fv", programUniform4fv);
        ASSIGN("glProgramUniform4i", programUniform4i);
        ASSIGN("glProgramUniform4iv", programUniform4iv);
        ASSIGN("glProgramUniform4ui", programUniform4ui);
        ASSIGN("glProgramUniform4uiv", programUniform4uiv);
        ASSIGN("glProgramUniformMatrix2dv", programUniformMatrix2dv);
        ASSIGN("glProgramUniformMatrix2fv", programUniformMatrix2fv);
        ASSIGN("glProgramUniformMatrix2x3dv", programUniformMatrix2x3dv);
        ASSIGN("glProgramUniformMatrix2x3fv", programUniformMatrix2x3fv);
        ASSIGN("glProgramUniformMatrix2x4dv", programUniformMatrix2x4dv);
        ASSIGN("glProgramUniformMatrix2x4fv", programUniformMatrix2x4fv);
        ASSIGN("glProgramUniformMatrix3dv", programUniformMatrix3dv);
        ASSIGN("glProgramUniformMatrix3fv", programUniformMatrix3fv);
        ASSIGN("glProgramUniformMatrix3x2dv", programUniformMatrix3x2dv);
        ASSIGN("glProgramUniformMatrix3x2fv", programUniformMatrix3x2fv);
        ASSIGN("glProgramUniformMatrix3x4dv", programUniformMatrix3x4dv);
        ASSIGN("glProgramUniformMatrix3x4fv", programUniformMatrix3x4fv);
        ASSIGN("glProgramUniformMatrix4dv", programUniformMatrix4dv);
        ASSIGN("glProgramUniformMatrix4fv", programUniformMatrix4fv);
        ASSIGN("glProgramUniformMatrix4x2dv", programUniformMatrix4x2dv);
        ASSIGN("glProgramUniformMatrix4x2fv", programUniformMatrix4x2fv);
        ASSIGN("glProgramUniformMatrix4x3dv", programUniformMatrix4x3dv);
        ASSIGN("glProgramUniformMatrix4x3fv", programUniformMatrix4x3fv);
        ASSIGN("glUseProgramStages", useProgramStages);
        ASSIGN("glValidateProgramPipeline", validateProgramPipeline);
    }

    if (extensions.count("GL_ARB_shader_atomic_counters") != 0)
    {
        ASSIGN("glGetActiveAtomicCounterBufferiv", getActiveAtomicCounterBufferiv);
    }

    if (extensions.count("GL_ARB_shader_image_load_store") != 0)
    {
        ASSIGN("glBindImageTexture", bindImageTexture);
        ASSIGN("glMemoryBarrier", memoryBarrier);
    }

    if (extensions.count("GL_ARB_shader_objects") != 0)
    {
        ASSIGN("glCompileShaderARB", compileShader);
        ASSIGN("glGetActiveUniformARB", getActiveUniform);
        ASSIGN("glGetShaderSourceARB", getShaderSource);
        ASSIGN("glGetUniformLocationARB", getUniformLocation);
        ASSIGN("glGetUniformfvARB", getUniformfv);
        ASSIGN("glGetUniformivARB", getUniformiv);
        ASSIGN("glLinkProgramARB", linkProgram);
        ASSIGN("glShaderSourceARB", shaderSource);
        ASSIGN("glUniform1fARB", uniform1f);
        ASSIGN("glUniform1fvARB", uniform1fv);
        ASSIGN("glUniform1iARB", uniform1i);
        ASSIGN("glUniform1ivARB", uniform1iv);
        ASSIGN("glUniform2fARB", uniform2f);
        ASSIGN("glUniform2fvARB", uniform2fv);
        ASSIGN("glUniform2iARB", uniform2i);
        ASSIGN("glUniform2ivARB", uniform2iv);
        ASSIGN("glUniform3fARB", uniform3f);
        ASSIGN("glUniform3fvARB", uniform3fv);
        ASSIGN("glUniform3iARB", uniform3i);
        ASSIGN("glUniform3ivARB", uniform3iv);
        ASSIGN("glUniform4fARB", uniform4f);
        ASSIGN("glUniform4fvARB", uniform4fv);
        ASSIGN("glUniform4iARB", uniform4i);
        ASSIGN("glUniform4ivARB", uniform4iv);
        ASSIGN("glUniformMatrix2fvARB", uniformMatrix2fv);
        ASSIGN("glUniformMatrix3fvARB", uniformMatrix3fv);
        ASSIGN("glUniformMatrix4fvARB", uniformMatrix4fv);
        ASSIGN("glValidateProgramARB", validateProgram);
    }

    if (extensions.count("GL_ARB_shader_storage_buffer_object") != 0)
    {
        ASSIGN("glShaderStorageBlockBinding", shaderStorageBlockBinding);
    }

    if (extensions.count("GL_ARB_shader_subroutine") != 0)
    {
        ASSIGN("glGetActiveSubroutineName", getActiveSubroutineName);
        ASSIGN("glGetActiveSubroutineUniformName", getActiveSubroutineUniformName);
        ASSIGN("glGetActiveSubroutineUniformiv", getActiveSubroutineUniformiv);
        ASSIGN("glGetProgramStageiv", getProgramStageiv);
        ASSIGN("glGetSubroutineIndex", getSubroutineIndex);
        ASSIGN("glGetSubroutineUniformLocation", getSubroutineUniformLocation);
        ASSIGN("glGetUniformSubroutineuiv", getUniformSubroutineuiv);
        ASSIGN("glUniformSubroutinesuiv", uniformSubroutinesuiv);
    }

    if (extensions.count("GL_ARB_sync") != 0)
    {
        ASSIGN("glClientWaitSync", clientWaitSync);
        ASSIGN("glDeleteSync", deleteSync);
        ASSIGN("glFenceSync", fenceSync);
        ASSIGN("glGetInteger64v", getInteger64v);
        ASSIGN("glGetSynciv", getSynciv);
        ASSIGN("glIsSync", isSync);
        ASSIGN("glWaitSync", waitSync);
    }

    if (extensions.count("GL_ARB_tessellation_shader") != 0)
    {
        ASSIGN("glPatchParameterfv", patchParameterfv);
        ASSIGN("glPatchParameteri", patchParameteri);
    }

    if (extensions.count("GL_ARB_texture_barrier") != 0)
    {
        ASSIGN("glTextureBarrier", textureBarrier);
    }

    if (extensions.count("GL_ARB_texture_buffer_object") != 0)
    {
        ASSIGN("glTexBufferARB", texBuffer);
    }

    if (extensions.count("GL_ARB_texture_buffer_range") != 0)
    {
        ASSIGN("glTexBufferRange", texBufferRange);
    }

    if (extensions.count("GL_ARB_texture_compression") != 0)
    {
        ASSIGN("glCompressedTexImage1DARB", compressedTexImage1D);
        ASSIGN("glCompressedTexImage2DARB", compressedTexImage2D);
        ASSIGN("glCompressedTexImage3DARB", compressedTexImage3D);
        ASSIGN("glCompressedTexSubImage1DARB", compressedTexSubImage1D);
        ASSIGN("glCompressedTexSubImage2DARB", compressedTexSubImage2D);
        ASSIGN("glCompressedTexSubImage3DARB", compressedTexSubImage3D);
        ASSIGN("glGetCompressedTexImageARB", getCompressedTexImage);
    }

    if (extensions.count("GL_ARB_texture_multisample") != 0)
    {
        ASSIGN("glGetMultisamplefv", getMultisamplefv);
        ASSIGN("glSampleMaski", sampleMaski);
        ASSIGN("glTexImage2DMultisample", texImage2DMultisample);
        ASSIGN("glTexImage3DMultisample", texImage3DMultisample);
    }

    if (extensions.count("GL_ARB_texture_storage") != 0)
    {
        ASSIGN("glTexStorage1D", texStorage1D);
        ASSIGN("glTexStorage2D", texStorage2D);
        ASSIGN("glTexStorage3D", texStorage3D);
    }

    if (extensions.count("GL_ARB_texture_storage_multisample") != 0)
    {
        ASSIGN("glTexStorage2DMultisample", texStorage2DMultisample);
        ASSIGN("glTexStorage3DMultisample", texStorage3DMultisample);
    }

    if (extensions.count("GL_ARB_texture_view") != 0)
    {
        ASSIGN("glTextureView", textureView);
    }

    if (extensions.count("GL_ARB_timer_query") != 0)
    {
        ASSIGN("glGetQueryObjecti64v", getQueryObjecti64v);
        ASSIGN("glGetQueryObjectui64v", getQueryObjectui64v);
        ASSIGN("glQueryCounter", queryCounter);
    }

    if (extensions.count("GL_ARB_transform_feedback2") != 0)
    {
        ASSIGN("glBindTransformFeedback", bindTransformFeedback);
        ASSIGN("glDeleteTransformFeedbacks", deleteTransformFeedbacks);
        ASSIGN("glDrawTransformFeedback", drawTransformFeedback);
        ASSIGN("glGenTransformFeedbacks", genTransformFeedbacks);
        ASSIGN("glIsTransformFeedback", isTransformFeedback);
        ASSIGN("glPauseTransformFeedback", pauseTransformFeedback);
        ASSIGN("glResumeTransformFeedback", resumeTransformFeedback);
    }

    if (extensions.count("GL_ARB_transform_feedback3") != 0)
    {
        ASSIGN("glBeginQueryIndexed", beginQueryIndexed);
        ASSIGN("glDrawTransformFeedbackStream", drawTransformFeedbackStream);
        ASSIGN("glEndQueryIndexed", endQueryIndexed);
        ASSIGN("glGetQueryIndexediv", getQueryIndexediv);
    }

    if (extensions.count("GL_ARB_transform_feedback_instanced") != 0)
    {
        ASSIGN("glDrawTransformFeedbackInstanced", drawTransformFeedbackInstanced);
        ASSIGN("glDrawTransformFeedbackStreamInstanced", drawTransformFeedbackStreamInstanced);
    }

    if (extensions.count("GL_ARB_uniform_buffer_object") != 0)
    {
        ASSIGN("glBindBufferBase", bindBufferBase);
        ASSIGN("glBindBufferRange", bindBufferRange);
        ASSIGN("glGetActiveUniformBlockName", getActiveUniformBlockName);
        ASSIGN("glGetActiveUniformBlockiv", getActiveUniformBlockiv);
        ASSIGN("glGetActiveUniformName", getActiveUniformName);
        ASSIGN("glGetActiveUniformsiv", getActiveUniformsiv);
        ASSIGN("glGetIntegeri_v", getIntegeri_v);
        ASSIGN("glGetUniformBlockIndex", getUniformBlockIndex);
        ASSIGN("glGetUniformIndices", getUniformIndices);
        ASSIGN("glUniformBlockBinding", uniformBlockBinding);
    }

    if (extensions.count("GL_ARB_vertex_array_object") != 0)
    {
        ASSIGN("glBindVertexArray", bindVertexArray);
        ASSIGN("glDeleteVertexArrays", deleteVertexArrays);
        ASSIGN("glGenVertexArrays", genVertexArrays);
        ASSIGN("glIsVertexArray", isVertexArray);
    }

    if (extensions.count("GL_ARB_vertex_attrib_64bit") != 0)
    {
        ASSIGN("glGetVertexAttribLdv", getVertexAttribLdv);
        ASSIGN("glVertexAttribL1d", vertexAttribL1d);
        ASSIGN("glVertexAttribL1dv", vertexAttribL1dv);
        ASSIGN("glVertexAttribL2d", vertexAttribL2d);
        ASSIGN("glVertexAttribL2dv", vertexAttribL2dv);
        ASSIGN("glVertexAttribL3d", vertexAttribL3d);
        ASSIGN("glVertexAttribL3dv", vertexAttribL3dv);
        ASSIGN("glVertexAttribL4d", vertexAttribL4d);
        ASSIGN("glVertexAttribL4dv", vertexAttribL4dv);
        ASSIGN("glVertexAttribLPointer", vertexAttribLPointer);
    }

    if (extensions.count("GL_ARB_vertex_attrib_binding") != 0)
    {
        ASSIGN("glBindVertexBuffer", bindVertexBuffer);
        ASSIGN("glVertexAttribBinding", vertexAttribBinding);
        ASSIGN("glVertexAttribFormat", vertexAttribFormat);
        ASSIGN("glVertexAttribIFormat", vertexAttribIFormat);
        ASSIGN("glVertexAttribLFormat", vertexAttribLFormat);
        ASSIGN("glVertexBindingDivisor", vertexBindingDivisor);
    }

    if (extensions.count("GL_ARB_vertex_buffer_object") != 0)
    {
        ASSIGN("glBindBufferARB", bindBuffer);
        ASSIGN("glBufferDataARB", bufferData);
        ASSIGN("glBufferSubDataARB", bufferSubData);
        ASSIGN("glDeleteBuffersARB", deleteBuffers);
        ASSIGN("glGenBuffersARB", genBuffers);
        ASSIGN("glGetBufferParameterivARB", getBufferParameteriv);
        ASSIGN("glGetBufferPointervARB", getBufferPointerv);
        ASSIGN("glGetBufferSubDataARB", getBufferSubData);
        ASSIGN("glIsBufferARB", isBuffer);
        ASSIGN("glMapBufferARB", mapBuffer);
        ASSIGN("glUnmapBufferARB", unmapBuffer);
    }

    if (extensions.count("GL_ARB_vertex_program") != 0)
    {
        ASSIGN("glDisableVertexAttribArrayARB", disableVertexAttribArray);
        ASSIGN("glEnableVertexAttribArrayARB", enableVertexAttribArray);
        ASSIGN("glGetProgramivARB", getProgramiv);
        ASSIGN("glGetVertexAttribPointervARB", getVertexAttribPointerv);
        ASSIGN("glGetVertexAttribdvARB", getVertexAttribdv);
        ASSIGN("glGetVertexAttribfvARB", getVertexAttribfv);
        ASSIGN("glGetVertexAttribivARB", getVertexAttribiv);
        ASSIGN("glIsProgramARB", isProgram);
        ASSIGN("glVertexAttrib1dARB", vertexAttrib1d);
        ASSIGN("glVertexAttrib1dvARB", vertexAttrib1dv);
        ASSIGN("glVertexAttrib1fARB", vertexAttrib1f);
        ASSIGN("glVertexAttrib1fvARB", vertexAttrib1fv);
        ASSIGN("glVertexAttrib1sARB", vertexAttrib1s);
        ASSIGN("glVertexAttrib1svARB", vertexAttrib1sv);
        ASSIGN("glVertexAttrib2dARB", vertexAttrib2d);
        ASSIGN("glVertexAttrib2dvARB", vertexAttrib2dv);
        ASSIGN("glVertexAttrib2fARB", vertexAttrib2f);
        ASSIGN("glVertexAttrib2fvARB", vertexAttrib2fv);
        ASSIGN("glVertexAttrib2sARB", vertexAttrib2s);
        ASSIGN("glVertexAttrib2svARB", vertexAttrib2sv);
        ASSIGN("glVertexAttrib3dARB", vertexAttrib3d);
        ASSIGN("glVertexAttrib3dvARB", vertexAttrib3dv);
        ASSIGN("glVertexAttrib3fARB", vertexAttrib3f);
        ASSIGN("glVertexAttrib3fvARB", vertexAttrib3fv);
        ASSIGN("glVertexAttrib3sARB", vertexAttrib3s);
        ASSIGN("glVertexAttrib3svARB", vertexAttrib3sv);
        ASSIGN("glVertexAttrib4NbvARB", vertexAttrib4Nbv);
        ASSIGN("glVertexAttrib4NivARB", vertexAttrib4Niv);
        ASSIGN("glVertexAttrib4NsvARB", vertexAttrib4Nsv);
        ASSIGN("glVertexAttrib4NubARB", vertexAttrib4Nub);
        ASSIGN("glVertexAttrib4NubvARB", vertexAttrib4Nubv);
        ASSIGN("glVertexAttrib4NuivARB", vertexAttrib4Nuiv);
        ASSIGN("glVertexAttrib4NusvARB", vertexAttrib4Nusv);
        ASSIGN("glVertexAttrib4bvARB", vertexAttrib4bv);
        ASSIGN("glVertexAttrib4dARB", vertexAttrib4d);
        ASSIGN("glVertexAttrib4dvARB", vertexAttrib4dv);
        ASSIGN("glVertexAttrib4fARB", vertexAttrib4f);
        ASSIGN("glVertexAttrib4fvARB", vertexAttrib4fv);
        ASSIGN("glVertexAttrib4ivARB", vertexAttrib4iv);
        ASSIGN("glVertexAttrib4sARB", vertexAttrib4s);
        ASSIGN("glVertexAttrib4svARB", vertexAttrib4sv);
        ASSIGN("glVertexAttrib4ubvARB", vertexAttrib4ubv);
        ASSIGN("glVertexAttrib4uivARB", vertexAttrib4uiv);
        ASSIGN("glVertexAttrib4usvARB", vertexAttrib4usv);
        ASSIGN("glVertexAttribPointerARB", vertexAttribPointer);
    }

    if (extensions.count("GL_ARB_vertex_shader") != 0)
    {
        ASSIGN("glBindAttribLocationARB", bindAttribLocation);
        ASSIGN("glDisableVertexAttribArrayARB", disableVertexAttribArray);
        ASSIGN("glEnableVertexAttribArrayARB", enableVertexAttribArray);
        ASSIGN("glGetActiveAttribARB", getActiveAttrib);
        ASSIGN("glGetAttribLocationARB", getAttribLocation);
        ASSIGN("glGetVertexAttribPointervARB", getVertexAttribPointerv);
        ASSIGN("glGetVertexAttribdvARB", getVertexAttribdv);
        ASSIGN("glGetVertexAttribfvARB", getVertexAttribfv);
        ASSIGN("glGetVertexAttribivARB", getVertexAttribiv);
        ASSIGN("glVertexAttrib1dARB", vertexAttrib1d);
        ASSIGN("glVertexAttrib1dvARB", vertexAttrib1dv);
        ASSIGN("glVertexAttrib1fARB", vertexAttrib1f);
        ASSIGN("glVertexAttrib1fvARB", vertexAttrib1fv);
        ASSIGN("glVertexAttrib1sARB", vertexAttrib1s);
        ASSIGN("glVertexAttrib1svARB", vertexAttrib1sv);
        ASSIGN("glVertexAttrib2dARB", vertexAttrib2d);
        ASSIGN("glVertexAttrib2dvARB", vertexAttrib2dv);
        ASSIGN("glVertexAttrib2fARB", vertexAttrib2f);
        ASSIGN("glVertexAttrib2fvARB", vertexAttrib2fv);
        ASSIGN("glVertexAttrib2sARB", vertexAttrib2s);
        ASSIGN("glVertexAttrib2svARB", vertexAttrib2sv);
        ASSIGN("glVertexAttrib3dARB", vertexAttrib3d);
        ASSIGN("glVertexAttrib3dvARB", vertexAttrib3dv);
        ASSIGN("glVertexAttrib3fARB", vertexAttrib3f);
        ASSIGN("glVertexAttrib3fvARB", vertexAttrib3fv);
        ASSIGN("glVertexAttrib3sARB", vertexAttrib3s);
        ASSIGN("glVertexAttrib3svARB", vertexAttrib3sv);
        ASSIGN("glVertexAttrib4NbvARB", vertexAttrib4Nbv);
        ASSIGN("glVertexAttrib4NivARB", vertexAttrib4Niv);
        ASSIGN("glVertexAttrib4NsvARB", vertexAttrib4Nsv);
        ASSIGN("glVertexAttrib4NubARB", vertexAttrib4Nub);
        ASSIGN("glVertexAttrib4NubvARB", vertexAttrib4Nubv);
        ASSIGN("glVertexAttrib4NuivARB", vertexAttrib4Nuiv);
        ASSIGN("glVertexAttrib4NusvARB", vertexAttrib4Nusv);
        ASSIGN("glVertexAttrib4bvARB", vertexAttrib4bv);
        ASSIGN("glVertexAttrib4dARB", vertexAttrib4d);
        ASSIGN("glVertexAttrib4dvARB", vertexAttrib4dv);
        ASSIGN("glVertexAttrib4fARB", vertexAttrib4f);
        ASSIGN("glVertexAttrib4fvARB", vertexAttrib4fv);
        ASSIGN("glVertexAttrib4ivARB", vertexAttrib4iv);
        ASSIGN("glVertexAttrib4sARB", vertexAttrib4s);
        ASSIGN("glVertexAttrib4svARB", vertexAttrib4sv);
        ASSIGN("glVertexAttrib4ubvARB", vertexAttrib4ubv);
        ASSIGN("glVertexAttrib4uivARB", vertexAttrib4uiv);
        ASSIGN("glVertexAttrib4usvARB", vertexAttrib4usv);
        ASSIGN("glVertexAttribPointerARB", vertexAttribPointer);
    }

    if (extensions.count("GL_ARB_vertex_type_2_10_10_10_rev") != 0)
    {
        ASSIGN("glVertexAttribP1ui", vertexAttribP1ui);
        ASSIGN("glVertexAttribP1uiv", vertexAttribP1uiv);
        ASSIGN("glVertexAttribP2ui", vertexAttribP2ui);
        ASSIGN("glVertexAttribP2uiv", vertexAttribP2uiv);
        ASSIGN("glVertexAttribP3ui", vertexAttribP3ui);
        ASSIGN("glVertexAttribP3uiv", vertexAttribP3uiv);
        ASSIGN("glVertexAttribP4ui", vertexAttribP4ui);
        ASSIGN("glVertexAttribP4uiv", vertexAttribP4uiv);
    }

    if (extensions.count("GL_ARB_viewport_array") != 0)
    {
        ASSIGN("glDepthRangeArrayv", depthRangeArrayv);
        ASSIGN("glDepthRangeIndexed", depthRangeIndexed);
        ASSIGN("glGetDoublei_v", getDoublei_v);
        ASSIGN("glGetFloati_v", getFloati_v);
        ASSIGN("glScissorArrayv", scissorArrayv);
        ASSIGN("glScissorIndexed", scissorIndexed);
        ASSIGN("glScissorIndexedv", scissorIndexedv);
        ASSIGN("glViewportArrayv", viewportArrayv);
        ASSIGN("glViewportIndexedf", viewportIndexedf);
        ASSIGN("glViewportIndexedfv", viewportIndexedfv);
    }

    if (extensions.count("GL_EXT_blend_color") != 0)
    {
        ASSIGN("glBlendColorEXT", blendColor);
    }

    if (extensions.count("GL_EXT_blend_equation_separate") != 0)
    {
        ASSIGN("glBlendEquationSeparateEXT", blendEquationSeparate);
    }

    if (extensions.count("GL_EXT_blend_func_separate") != 0)
    {
        ASSIGN("glBlendFuncSeparateEXT", blendFuncSeparate);
    }

    if (extensions.count("GL_EXT_copy_texture") != 0)
    {
        ASSIGN("glCopyTexImage1DEXT", copyTexImage1D);
        ASSIGN("glCopyTexImage2DEXT", copyTexImage2D);
        ASSIGN("glCopyTexSubImage1DEXT", copyTexSubImage1D);
        ASSIGN("glCopyTexSubImage2DEXT", copyTexSubImage2D);
        ASSIGN("glCopyTexSubImage3DEXT", copyTexSubImage3D);
    }

    if (extensions.count("GL_EXT_direct_state_access") != 0)
    {
        ASSIGN("glCheckNamedFramebufferStatusEXT", checkNamedFramebufferStatus);
        ASSIGN("glClearNamedBufferDataEXT", clearNamedBufferData);
        ASSIGN("glClearNamedBufferSubDataEXT", clearNamedBufferSubData);
        ASSIGN("glCompressedTextureSubImage1DEXT", compressedTextureSubImage1D);
        ASSIGN("glCompressedTextureSubImage2DEXT", compressedTextureSubImage2D);
        ASSIGN("glCompressedTextureSubImage3DEXT", compressedTextureSubImage3D);
        ASSIGN("glCopyTextureSubImage1DEXT", copyTextureSubImage1D);
        ASSIGN("glCopyTextureSubImage2DEXT", copyTextureSubImage2D);
        ASSIGN("glCopyTextureSubImage3DEXT", copyTextureSubImage3D);
        ASSIGN("glDisableVertexArrayAttribEXT", disableVertexArrayAttrib);
        ASSIGN("glEnableVertexArrayAttribEXT", enableVertexArrayAttrib);
        ASSIGN("glFlushMappedNamedBufferRangeEXT", flushMappedNamedBufferRange);
        ASSIGN("glGenerateTextureMipmapEXT", generateTextureMipmap);
        ASSIGN("glGetCompressedTextureImageEXT", getCompressedTextureImage);
        ASSIGN("glGetDoublei_vEXT", getDoublei_v);
        ASSIGN("glGetFloati_vEXT", getFloati_v);
        ASSIGN("glGetFramebufferParameterivEXT", getFramebufferParameteriv);
        ASSIGN("glGetNamedBufferParameterivEXT", getNamedBufferParameteriv);
        ASSIGN("glGetNamedBufferPointervEXT", getNamedBufferPointerv);
        ASSIGN("glGetNamedBufferSubDataEXT", getNamedBufferSubData);
        ASSIGN("glGetNamedFramebufferAttachmentParameterivEXT",
               getNamedFramebufferAttachmentParameteriv);
        ASSIGN("glGetNamedFramebufferParameterivEXT", getNamedFramebufferParameteriv);
        ASSIGN("glGetNamedRenderbufferParameterivEXT", getNamedRenderbufferParameteriv);
        ASSIGN("glGetTextureImageEXT", getTextureImage);
        ASSIGN("glGetTextureLevelParameterfvEXT", getTextureLevelParameterfv);
        ASSIGN("glGetTextureLevelParameterivEXT", getTextureLevelParameteriv);
        ASSIGN("glGetTextureParameterIivEXT", getTextureParameterIiv);
        ASSIGN("glGetTextureParameterIuivEXT", getTextureParameterIuiv);
        ASSIGN("glGetTextureParameterfvEXT", getTextureParameterfv);
        ASSIGN("glGetTextureParameterivEXT", getTextureParameteriv);
        ASSIGN("glMapNamedBufferEXT", mapNamedBuffer);
        ASSIGN("glMapNamedBufferRangeEXT", mapNamedBufferRange);
        ASSIGN("glNamedBufferDataEXT", namedBufferData);
        ASSIGN("glNamedBufferStorageEXT", namedBufferStorage);
        ASSIGN("glNamedBufferSubDataEXT", namedBufferSubData);
        ASSIGN("glNamedFramebufferParameteriEXT", namedFramebufferParameteri);
        ASSIGN("glNamedFramebufferRenderbufferEXT", namedFramebufferRenderbuffer);
        ASSIGN("glNamedFramebufferTextureEXT", namedFramebufferTexture);
        ASSIGN("glNamedFramebufferTextureLayerEXT", namedFramebufferTextureLayer);
        ASSIGN("glNamedRenderbufferStorageEXT", namedRenderbufferStorage);
        ASSIGN("glNamedRenderbufferStorageMultisampleEXT", namedRenderbufferStorageMultisample);
        ASSIGN("glProgramUniform1dEXT", programUniform1d);
        ASSIGN("glProgramUniform1dvEXT", programUniform1dv);
        ASSIGN("glProgramUniform2dEXT", programUniform2d);
        ASSIGN("glProgramUniform2dvEXT", programUniform2dv);
        ASSIGN("glProgramUniform3dEXT", programUniform3d);
        ASSIGN("glProgramUniform3dvEXT", programUniform3dv);
        ASSIGN("glProgramUniform4dEXT", programUniform4d);
        ASSIGN("glProgramUniform4dvEXT", programUniform4dv);
        ASSIGN("glProgramUniformMatrix2dvEXT", programUniformMatrix2dv);
        ASSIGN("glProgramUniformMatrix2x3dvEXT", programUniformMatrix2x3dv);
        ASSIGN("glProgramUniformMatrix2x4dvEXT", programUniformMatrix2x4dv);
        ASSIGN("glProgramUniformMatrix3dvEXT", programUniformMatrix3dv);
        ASSIGN("glProgramUniformMatrix3x2dvEXT", programUniformMatrix3x2dv);
        ASSIGN("glProgramUniformMatrix3x4dvEXT", programUniformMatrix3x4dv);
        ASSIGN("glProgramUniformMatrix4dvEXT", programUniformMatrix4dv);
        ASSIGN("glProgramUniformMatrix4x2dvEXT", programUniformMatrix4x2dv);
        ASSIGN("glProgramUniformMatrix4x3dvEXT", programUniformMatrix4x3dv);
        ASSIGN("glTextureBufferEXT", textureBuffer);
        ASSIGN("glTextureBufferRangeEXT", textureBufferRange);
        ASSIGN("glTextureParameterIivEXT", textureParameterIiv);
        ASSIGN("glTextureParameterIuivEXT", textureParameterIuiv);
        ASSIGN("glTextureParameterfEXT", textureParameterf);
        ASSIGN("glTextureParameterfvEXT", textureParameterfv);
        ASSIGN("glTextureParameteriEXT", textureParameteri);
        ASSIGN("glTextureParameterivEXT", textureParameteriv);
        ASSIGN("glTextureStorage1DEXT", textureStorage1D);
        ASSIGN("glTextureStorage2DEXT", textureStorage2D);
        ASSIGN("glTextureStorage2DMultisampleEXT", textureStorage2DMultisample);
        ASSIGN("glTextureStorage3DEXT", textureStorage3D);
        ASSIGN("glTextureStorage3DMultisampleEXT", textureStorage3DMultisample);
        ASSIGN("glTextureSubImage1DEXT", textureSubImage1D);
        ASSIGN("glTextureSubImage2DEXT", textureSubImage2D);
        ASSIGN("glTextureSubImage3DEXT", textureSubImage3D);
        ASSIGN("glUnmapNamedBufferEXT", unmapNamedBuffer);
    }

    if (extensions.count("GL_EXT_draw_range_elements") != 0)
    {
        ASSIGN("glDrawRangeElementsEXT", drawRangeElements);
    }

    if (extensions.count("GL_EXT_framebuffer_blit") != 0)
    {
        ASSIGN("glBlitFramebufferEXT", blitFramebuffer);
    }

    if (extensions.count("GL_EXT_framebuffer_multisample") != 0)
    {
        ASSIGN("glRenderbufferStorageMultisampleEXT", renderbufferStorageMultisample);
    }

    if (extensions.count("GL_EXT_framebuffer_object") != 0)
    {
        ASSIGN("glBindFramebufferEXT", bindFramebuffer);
        ASSIGN("glBindRenderbufferEXT", bindRenderbuffer);
        ASSIGN("glCheckFramebufferStatusEXT", checkFramebufferStatus);
        ASSIGN("glDeleteFramebuffersEXT", deleteFramebuffers);
        ASSIGN("glDeleteRenderbuffersEXT", deleteRenderbuffers);
        ASSIGN("glFramebufferRenderbufferEXT", framebufferRenderbuffer);
        ASSIGN("glFramebufferTexture1DEXT", framebufferTexture1D);
        ASSIGN("glFramebufferTexture2DEXT", framebufferTexture2D);
        ASSIGN("glFramebufferTexture3DEXT", framebufferTexture3D);
        ASSIGN("glGenFramebuffersEXT", genFramebuffers);
        ASSIGN("glGenRenderbuffersEXT", genRenderbuffers);
        ASSIGN("glGenerateMipmapEXT", generateMipmap);
        ASSIGN("glGetFramebufferAttachmentParameterivEXT", getFramebufferAttachmentParameteriv);
        ASSIGN("glGetRenderbufferParameterivEXT", getRenderbufferParameteriv);
        ASSIGN("glIsFramebufferEXT", isFramebuffer);
        ASSIGN("glIsRenderbufferEXT", isRenderbuffer);
        ASSIGN("glRenderbufferStorageEXT", renderbufferStorage);
    }

    if (extensions.count("GL_EXT_gpu_shader4") != 0)
    {
        ASSIGN("glBindFragDataLocationEXT", bindFragDataLocation);
        ASSIGN("glGetFragDataLocationEXT", getFragDataLocation);
        ASSIGN("glGetUniformuivEXT", getUniformuiv);
        ASSIGN("glUniform1uiEXT", uniform1ui);
        ASSIGN("glUniform1uivEXT", uniform1uiv);
        ASSIGN("glUniform2uiEXT", uniform2ui);
        ASSIGN("glUniform2uivEXT", uniform2uiv);
        ASSIGN("glUniform3uiEXT", uniform3ui);
        ASSIGN("glUniform3uivEXT", uniform3uiv);
        ASSIGN("glUniform4uiEXT", uniform4ui);
        ASSIGN("glUniform4uivEXT", uniform4uiv);
    }

    if (extensions.count("GL_EXT_point_parameters") != 0)
    {
        ASSIGN("glPointParameterfEXT", pointParameterf);
        ASSIGN("glPointParameterfvEXT", pointParameterfv);
    }

    if (extensions.count("GL_EXT_polygon_offset") != 0)
    {
        ASSIGN("glPolygonOffsetEXT", polygonOffset);
    }

    if (extensions.count("GL_EXT_provoking_vertex") != 0)
    {
        ASSIGN("glProvokingVertexEXT", provokingVertex);
    }

    if (extensions.count("GL_EXT_shader_image_load_store") != 0)
    {
        ASSIGN("glBindImageTextureEXT", bindImageTexture);
        ASSIGN("glMemoryBarrierEXT", memoryBarrier);
    }

    if (extensions.count("GL_EXT_subtexture") != 0)
    {
        ASSIGN("glTexSubImage1DEXT", texSubImage1D);
        ASSIGN("glTexSubImage2DEXT", texSubImage2D);
    }

    if (extensions.count("GL_EXT_texture3D") != 0)
    {
        ASSIGN("glTexImage3DEXT", texImage3D);
        ASSIGN("glTexSubImage3DEXT", texSubImage3D);
    }

    if (extensions.count("GL_EXT_texture_array") != 0)
    {
        ASSIGN("glFramebufferTextureLayerEXT", framebufferTextureLayer);
    }

    if (extensions.count("GL_EXT_texture_buffer_object") != 0)
    {
        ASSIGN("glTexBufferEXT", texBuffer);
    }

    if (extensions.count("GL_EXT_texture_integer") != 0)
    {
        ASSIGN("glGetTexParameterIivEXT", getTexParameterIiv);
        ASSIGN("glGetTexParameterIuivEXT", getTexParameterIuiv);
        ASSIGN("glTexParameterIivEXT", texParameterIiv);
        ASSIGN("glTexParameterIuivEXT", texParameterIuiv);
    }

    if (extensions.count("GL_EXT_texture_object") != 0)
    {
        ASSIGN("glBindTextureEXT", bindTexture);
        ASSIGN("glDeleteTexturesEXT", deleteTextures);
        ASSIGN("glGenTexturesEXT", genTextures);
        ASSIGN("glIsTextureEXT", isTexture);
    }

    if (extensions.count("GL_EXT_timer_query") != 0)
    {
        ASSIGN("glGetQueryObjecti64vEXT", getQueryObjecti64v);
        ASSIGN("glGetQueryObjectui64vEXT", getQueryObjectui64v);
    }

    if (extensions.count("GL_EXT_transform_feedback") != 0)
    {
        ASSIGN("glBeginTransformFeedbackEXT", beginTransformFeedback);
        ASSIGN("glBindBufferBaseEXT", bindBufferBase);
        ASSIGN("glBindBufferRangeEXT", bindBufferRange);
        ASSIGN("glEndTransformFeedbackEXT", endTransformFeedback);
        ASSIGN("glGetTransformFeedbackVaryingEXT", getTransformFeedbackVarying);
        ASSIGN("glTransformFeedbackVaryingsEXT", transformFeedbackVaryings);
    }

    if (extensions.count("GL_EXT_vertex_array") != 0)
    {
        ASSIGN("glDrawArraysEXT", drawArrays);
        ASSIGN("glGetPointervEXT", getPointerv);
    }

    if (extensions.count("GL_EXT_vertex_attrib_64bit") != 0)
    {
        ASSIGN("glGetVertexAttribLdvEXT", getVertexAttribLdv);
        ASSIGN("glVertexAttribL1dEXT", vertexAttribL1d);
        ASSIGN("glVertexAttribL1dvEXT", vertexAttribL1dv);
        ASSIGN("glVertexAttribL2dEXT", vertexAttribL2d);
        ASSIGN("glVertexAttribL2dvEXT", vertexAttribL2dv);
        ASSIGN("glVertexAttribL3dEXT", vertexAttribL3d);
        ASSIGN("glVertexAttribL3dvEXT", vertexAttribL3dv);
        ASSIGN("glVertexAttribL4dEXT", vertexAttribL4d);
        ASSIGN("glVertexAttribL4dvEXT", vertexAttribL4dv);
        ASSIGN("glVertexAttribLPointerEXT", vertexAttribLPointer);
    }

    if (extensions.count("GL_KHR_debug") != 0)
    {
        ASSIGN("glDebugMessageCallback", debugMessageCallback);
        ASSIGN("glDebugMessageControl", debugMessageControl);
        ASSIGN("glDebugMessageInsert", debugMessageInsert);
        ASSIGN("glGetDebugMessageLog", getDebugMessageLog);
        ASSIGN("glGetObjectLabel", getObjectLabel);
        ASSIGN("glGetObjectPtrLabel", getObjectPtrLabel);
        ASSIGN("glGetPointerv", getPointerv);
        ASSIGN("glObjectLabel", objectLabel);
        ASSIGN("glObjectPtrLabel", objectPtrLabel);
        ASSIGN("glPopDebugGroup", popDebugGroup);
        ASSIGN("glPushDebugGroup", pushDebugGroup);
    }

    if (extensions.count("GL_KHR_robustness") != 0)
    {
        ASSIGN("glGetGraphicsResetStatus", getGraphicsResetStatus);
        ASSIGN("glGetnUniformfv", getnUniformfv);
        ASSIGN("glGetnUniformiv", getnUniformiv);
        ASSIGN("glGetnUniformuiv", getnUniformuiv);
        ASSIGN("glReadnPixels", readnPixels);
    }

    if (extensions.count("GL_NV_geometry_program4") != 0)
    {
        ASSIGN("glFramebufferTextureEXT", framebufferTexture);
        ASSIGN("glFramebufferTextureLayerEXT", framebufferTextureLayer);
    }

    if (extensions.count("GL_NV_vertex_program4") != 0)
    {
        ASSIGN("glGetVertexAttribIivEXT", getVertexAttribIiv);
        ASSIGN("glGetVertexAttribIuivEXT", getVertexAttribIuiv);
        ASSIGN("glVertexAttribI1iEXT", vertexAttribI1i);
        ASSIGN("glVertexAttribI1ivEXT", vertexAttribI1iv);
        ASSIGN("glVertexAttribI1uiEXT", vertexAttribI1ui);
        ASSIGN("glVertexAttribI1uivEXT", vertexAttribI1uiv);
        ASSIGN("glVertexAttribI2iEXT", vertexAttribI2i);
        ASSIGN("glVertexAttribI2ivEXT", vertexAttribI2iv);
        ASSIGN("glVertexAttribI2uiEXT", vertexAttribI2ui);
        ASSIGN("glVertexAttribI2uivEXT", vertexAttribI2uiv);
        ASSIGN("glVertexAttribI3iEXT", vertexAttribI3i);
        ASSIGN("glVertexAttribI3ivEXT", vertexAttribI3iv);
        ASSIGN("glVertexAttribI3uiEXT", vertexAttribI3ui);
        ASSIGN("glVertexAttribI3uivEXT", vertexAttribI3uiv);
        ASSIGN("glVertexAttribI4bvEXT", vertexAttribI4bv);
        ASSIGN("glVertexAttribI4iEXT", vertexAttribI4i);
        ASSIGN("glVertexAttribI4ivEXT", vertexAttribI4iv);
        ASSIGN("glVertexAttribI4svEXT", vertexAttribI4sv);
        ASSIGN("glVertexAttribI4ubvEXT", vertexAttribI4ubv);
        ASSIGN("glVertexAttribI4uiEXT", vertexAttribI4ui);
        ASSIGN("glVertexAttribI4uivEXT", vertexAttribI4uiv);
        ASSIGN("glVertexAttribI4usvEXT", vertexAttribI4usv);
        ASSIGN("glVertexAttribIPointerEXT", vertexAttribIPointer);
    }

    if (extensions.count("GL_OES_single_precision") != 0)
    {
        ASSIGN("glClearDepthfOES", clearDepthf);
        ASSIGN("glDepthRangefOES", depthRangef);
    }
}

void DispatchTableGL::initProcsGLES(const gl::Version &version,
                                    const std::set<std::string> &extensions)
{
    if (version >= gl::Version(2, 0))
    {
        ASSIGN("glActiveTexture", activeTexture);
        ASSIGN("glAttachShader", attachShader);
        ASSIGN("glBindAttribLocation", bindAttribLocation);
        ASSIGN("glBindBuffer", bindBuffer);
        ASSIGN("glBindFramebuffer", bindFramebuffer);
        ASSIGN("glBindRenderbuffer", bindRenderbuffer);
        ASSIGN("glBindTexture", bindTexture);
        ASSIGN("glBlendColor", blendColor);
        ASSIGN("glBlendEquation", blendEquation);
        ASSIGN("glBlendEquationSeparate", blendEquationSeparate);
        ASSIGN("glBlendFunc", blendFunc);
        ASSIGN("glBlendFuncSeparate", blendFuncSeparate);
        ASSIGN("glBufferData", bufferData);
        ASSIGN("glBufferSubData", bufferSubData);
        ASSIGN("glCheckFramebufferStatus", checkFramebufferStatus);
        ASSIGN("glClear", clear);
        ASSIGN("glClearColor", clearColor);
        ASSIGN("glClearDepthf", clearDepthf);
        ASSIGN("glClearStencil", clearStencil);
        ASSIGN("glColorMask", colorMask);
        ASSIGN("glCompileShader", compileShader);
        ASSIGN("glCompressedTexImage2D", compressedTexImage2D);
        ASSIGN("glCompressedTexSubImage2D", compressedTexSubImage2D);
        ASSIGN("glCopyTexImage2D", copyTexImage2D);
        ASSIGN("glCopyTexSubImage2D", copyTexSubImage2D);
        ASSIGN("glCreateProgram", createProgram);
        ASSIGN("glCreateShader", createShader);
        ASSIGN("glCullFace", cullFace);
        ASSIGN("glDeleteBuffers", deleteBuffers);
        ASSIGN("glDeleteFramebuffers", deleteFramebuffers);
        ASSIGN("glDeleteProgram", deleteProgram);
        ASSIGN("glDeleteRenderbuffers", deleteRenderbuffers);
        ASSIGN("glDeleteShader", deleteShader);
        ASSIGN("glDeleteTextures", deleteTextures);
        ASSIGN("glDepthFunc", depthFunc);
        ASSIGN("glDepthMask", depthMask);
        ASSIGN("glDepthRangef", depthRangef);
        ASSIGN("glDetachShader", detachShader);
        ASSIGN("glDisable", disable);
        ASSIGN("glDisableVertexAttribArray", disableVertexAttribArray);
        ASSIGN("glDrawArrays", drawArrays);
        ASSIGN("glDrawElements", drawElements);
        ASSIGN("glEnable", enable);
        ASSIGN("glEnableVertexAttribArray", enableVertexAttribArray);
        ASSIGN("glFinish", finish);
        ASSIGN("glFlush", flush);
        ASSIGN("glFramebufferRenderbuffer", framebufferRenderbuffer);
        ASSIGN("glFramebufferTexture2D", framebufferTexture2D);
        ASSIGN("glFrontFace", frontFace);
        ASSIGN("glGenBuffers", genBuffers);
        ASSIGN("glGenFramebuffers", genFramebuffers);
        ASSIGN("glGenRenderbuffers", genRenderbuffers);
        ASSIGN("glGenTextures", genTextures);
        ASSIGN("glGenerateMipmap", generateMipmap);
        ASSIGN("glGetActiveAttrib", getActiveAttrib);
        ASSIGN("glGetActiveUniform", getActiveUniform);
        ASSIGN("glGetAttachedShaders", getAttachedShaders);
        ASSIGN("glGetAttribLocation", getAttribLocation);
        ASSIGN("glGetBooleanv", getBooleanv);
        ASSIGN("glGetBufferParameteriv", getBufferParameteriv);
        ASSIGN("glGetError", getError);
        ASSIGN("glGetFloatv", getFloatv);
        ASSIGN("glGetFramebufferAttachmentParameteriv", getFramebufferAttachmentParameteriv);
        ASSIGN("glGetIntegerv", getIntegerv);
        ASSIGN("glGetProgramInfoLog", getProgramInfoLog);
        ASSIGN("glGetProgramiv", getProgramiv);
        ASSIGN("glGetRenderbufferParameteriv", getRenderbufferParameteriv);
        ASSIGN("glGetShaderInfoLog", getShaderInfoLog);
        ASSIGN("glGetShaderPrecisionFormat", getShaderPrecisionFormat);
        ASSIGN("glGetShaderSource", getShaderSource);
        ASSIGN("glGetShaderiv", getShaderiv);
        ASSIGN("glGetString", getString);
        ASSIGN("glGetTexParameterfv", getTexParameterfv);
        ASSIGN("glGetTexParameteriv", getTexParameteriv);
        ASSIGN("glGetUniformLocation", getUniformLocation);
        ASSIGN("glGetUniformfv", getUniformfv);
        ASSIGN("glGetUniformiv", getUniformiv);
        ASSIGN("glGetVertexAttribPointerv", getVertexAttribPointerv);
        ASSIGN("glGetVertexAttribfv", getVertexAttribfv);
        ASSIGN("glGetVertexAttribiv", getVertexAttribiv);
        ASSIGN("glHint", hint);
        ASSIGN("glIsBuffer", isBuffer);
        ASSIGN("glIsEnabled", isEnabled);
        ASSIGN("glIsFramebuffer", isFramebuffer);
        ASSIGN("glIsProgram", isProgram);
        ASSIGN("glIsRenderbuffer", isRenderbuffer);
        ASSIGN("glIsShader", isShader);
        ASSIGN("glIsTexture", isTexture);
        ASSIGN("glLineWidth", lineWidth);
        ASSIGN("glLinkProgram", linkProgram);
        ASSIGN("glPixelStorei", pixelStorei);
        ASSIGN("glPolygonOffset", polygonOffset);
        ASSIGN("glReadPixels", readPixels);
        ASSIGN("glReleaseShaderCompiler", releaseShaderCompiler);
        ASSIGN("glRenderbufferStorage", renderbufferStorage);
        ASSIGN("glSampleCoverage", sampleCoverage);
        ASSIGN("glScissor", scissor);
        ASSIGN("glShaderBinary", shaderBinary);
        ASSIGN("glShaderSource", shaderSource);
        ASSIGN("glStencilFunc", stencilFunc);
        ASSIGN("glStencilFuncSeparate", stencilFuncSeparate);
        ASSIGN("glStencilMask", stencilMask);
        ASSIGN("glStencilMaskSeparate", stencilMaskSeparate);
        ASSIGN("glStencilOp", stencilOp);
        ASSIGN("glStencilOpSeparate", stencilOpSeparate);
        ASSIGN("glTexImage2D", texImage2D);
        ASSIGN("glTexParameterf", texParameterf);
        ASSIGN("glTexParameterfv", texParameterfv);
        ASSIGN("glTexParameteri", texParameteri);
        ASSIGN("glTexParameteriv", texParameteriv);
        ASSIGN("glTexSubImage2D", texSubImage2D);
        ASSIGN("glUniform1f", uniform1f);
        ASSIGN("glUniform1fv", uniform1fv);
        ASSIGN("glUniform1i", uniform1i);
        ASSIGN("glUniform1iv", uniform1iv);
        ASSIGN("glUniform2f", uniform2f);
        ASSIGN("glUniform2fv", uniform2fv);
        ASSIGN("glUniform2i", uniform2i);
        ASSIGN("glUniform2iv", uniform2iv);
        ASSIGN("glUniform3f", uniform3f);
        ASSIGN("glUniform3fv", uniform3fv);
        ASSIGN("glUniform3i", uniform3i);
        ASSIGN("glUniform3iv", uniform3iv);
        ASSIGN("glUniform4f", uniform4f);
        ASSIGN("glUniform4fv", uniform4fv);
        ASSIGN("glUniform4i", uniform4i);
        ASSIGN("glUniform4iv", uniform4iv);
        ASSIGN("glUniformMatrix2fv", uniformMatrix2fv);
        ASSIGN("glUniformMatrix3fv", uniformMatrix3fv);
        ASSIGN("glUniformMatrix4fv", uniformMatrix4fv);
        ASSIGN("glUseProgram", useProgram);
        ASSIGN("glValidateProgram", validateProgram);
        ASSIGN("glVertexAttrib1f", vertexAttrib1f);
        ASSIGN("glVertexAttrib1fv", vertexAttrib1fv);
        ASSIGN("glVertexAttrib2f", vertexAttrib2f);
        ASSIGN("glVertexAttrib2fv", vertexAttrib2fv);
        ASSIGN("glVertexAttrib3f", vertexAttrib3f);
        ASSIGN("glVertexAttrib3fv", vertexAttrib3fv);
        ASSIGN("glVertexAttrib4f", vertexAttrib4f);
        ASSIGN("glVertexAttrib4fv", vertexAttrib4fv);
        ASSIGN("glVertexAttribPointer", vertexAttribPointer);
        ASSIGN("glViewport", viewport);
    }

    if (version >= gl::Version(3, 0))
    {
        ASSIGN("glBeginQuery", beginQuery);
        ASSIGN("glBeginTransformFeedback", beginTransformFeedback);
        ASSIGN("glBindBufferBase", bindBufferBase);
        ASSIGN("glBindBufferRange", bindBufferRange);
        ASSIGN("glBindSampler", bindSampler);
        ASSIGN("glBindTransformFeedback", bindTransformFeedback);
        ASSIGN("glBindVertexArray", bindVertexArray);
        ASSIGN("glBlitFramebuffer", blitFramebuffer);
        ASSIGN("glClearBufferfi", clearBufferfi);
        ASSIGN("glClearBufferfv", clearBufferfv);
        ASSIGN("glClearBufferiv", clearBufferiv);
        ASSIGN("glClearBufferuiv", clearBufferuiv);
        ASSIGN("glClientWaitSync", clientWaitSync);
        ASSIGN("glCompressedTexImage3D", compressedTexImage3D);
        ASSIGN("glCompressedTexSubImage3D", compressedTexSubImage3D);
        ASSIGN("glCopyBufferSubData", copyBufferSubData);
        ASSIGN("glCopyTexSubImage3D", copyTexSubImage3D);
        ASSIGN("glDeleteQueries", deleteQueries);
        ASSIGN("glDeleteSamplers", deleteSamplers);
        ASSIGN("glDeleteSync", deleteSync);
        ASSIGN("glDeleteTransformFeedbacks", deleteTransformFeedbacks);
        ASSIGN("glDeleteVertexArrays", deleteVertexArrays);
        ASSIGN("glDrawArraysInstanced", drawArraysInstanced);
        ASSIGN("glDrawBuffers", drawBuffers);
        ASSIGN("glDrawElementsInstanced", drawElementsInstanced);
        ASSIGN("glDrawRangeElements", drawRangeElements);
        ASSIGN("glEndQuery", endQuery);
        ASSIGN("glEndTransformFeedback", endTransformFeedback);
        ASSIGN("glFenceSync", fenceSync);
        ASSIGN("glFlushMappedBufferRange", flushMappedBufferRange);
        ASSIGN("glFramebufferTextureLayer", framebufferTextureLayer);
        ASSIGN("glGenQueries", genQueries);
        ASSIGN("glGenSamplers", genSamplers);
        ASSIGN("glGenTransformFeedbacks", genTransformFeedbacks);
        ASSIGN("glGenVertexArrays", genVertexArrays);
        ASSIGN("glGetActiveUniformBlockName", getActiveUniformBlockName);
        ASSIGN("glGetActiveUniformBlockiv", getActiveUniformBlockiv);
        ASSIGN("glGetActiveUniformsiv", getActiveUniformsiv);
        ASSIGN("glGetBufferParameteri64v", getBufferParameteri64v);
        ASSIGN("glGetBufferPointerv", getBufferPointerv);
        ASSIGN("glGetFragDataLocation", getFragDataLocation);
        ASSIGN("glGetInteger64i_v", getInteger64i_v);
        ASSIGN("glGetInteger64v", getInteger64v);
        ASSIGN("glGetIntegeri_v", getIntegeri_v);
        ASSIGN("glGetInternalformativ", getInternalformativ);
        ASSIGN("glGetProgramBinary", getProgramBinary);
        ASSIGN("glGetQueryObjectuiv", getQueryObjectuiv);
        ASSIGN("glGetQueryiv", getQueryiv);
        ASSIGN("glGetSamplerParameterfv", getSamplerParameterfv);
        ASSIGN("glGetSamplerParameteriv", getSamplerParameteriv);
        ASSIGN("glGetStringi", getStringi);
        ASSIGN("glGetSynciv", getSynciv);
        ASSIGN("glGetTransformFeedbackVarying", getTransformFeedbackVarying);
        ASSIGN("glGetUniformBlockIndex", getUniformBlockIndex);
        ASSIGN("glGetUniformIndices", getUniformIndices);
        ASSIGN("glGetUniformuiv", getUniformuiv);
        ASSIGN("glGetVertexAttribIiv", getVertexAttribIiv);
        ASSIGN("glGetVertexAttribIuiv", getVertexAttribIuiv);
        ASSIGN("glInvalidateFramebuffer", invalidateFramebuffer);
        ASSIGN("glInvalidateSubFramebuffer", invalidateSubFramebuffer);
        ASSIGN("glIsQuery", isQuery);
        ASSIGN("glIsSampler", isSampler);
        ASSIGN("glIsSync", isSync);
        ASSIGN("glIsTransformFeedback", isTransformFeedback);
        ASSIGN("glIsVertexArray", isVertexArray);
        ASSIGN("glMapBufferRange", mapBufferRange);
        ASSIGN("glPauseTransformFeedback", pauseTransformFeedback);
        ASSIGN("glProgramBinary", programBinary);
        ASSIGN("glProgramParameteri", programParameteri);
        ASSIGN("glReadBuffer", readBuffer);
        ASSIGN("glRenderbufferStorageMultisample", renderbufferStorageMultisample);
        ASSIGN("glResumeTransformFeedback", resumeTransformFeedback);
        ASSIGN("glSamplerParameterf", samplerParameterf);
        ASSIGN("glSamplerParameterfv", samplerParameterfv);
        ASSIGN("glSamplerParameteri", samplerParameteri);
        ASSIGN("glSamplerParameteriv", samplerParameteriv);
        ASSIGN("glTexImage3D", texImage3D);
        ASSIGN("glTexStorage2D", texStorage2D);
        ASSIGN("glTexStorage3D", texStorage3D);
        ASSIGN("glTexSubImage3D", texSubImage3D);
        ASSIGN("glTransformFeedbackVaryings", transformFeedbackVaryings);
        ASSIGN("glUniform1ui", uniform1ui);
        ASSIGN("glUniform1uiv", uniform1uiv);
        ASSIGN("glUniform2ui", uniform2ui);
        ASSIGN("glUniform2uiv", uniform2uiv);
        ASSIGN("glUniform3ui", uniform3ui);
        ASSIGN("glUniform3uiv", uniform3uiv);
        ASSIGN("glUniform4ui", uniform4ui);
        ASSIGN("glUniform4uiv", uniform4uiv);
        ASSIGN("glUniformBlockBinding", uniformBlockBinding);
        ASSIGN("glUniformMatrix2x3fv", uniformMatrix2x3fv);
        ASSIGN("glUniformMatrix2x4fv", uniformMatrix2x4fv);
        ASSIGN("glUniformMatrix3x2fv", uniformMatrix3x2fv);
        ASSIGN("glUniformMatrix3x4fv", uniformMatrix3x4fv);
        ASSIGN("glUniformMatrix4x2fv", uniformMatrix4x2fv);
        ASSIGN("glUniformMatrix4x3fv", uniformMatrix4x3fv);
        ASSIGN("glUnmapBuffer", unmapBuffer);
        ASSIGN("glVertexAttribDivisor", vertexAttribDivisor);
        ASSIGN("glVertexAttribI4i", vertexAttribI4i);
        ASSIGN("glVertexAttribI4iv", vertexAttribI4iv);
        ASSIGN("glVertexAttribI4ui", vertexAttribI4ui);
        ASSIGN("glVertexAttribI4uiv", vertexAttribI4uiv);
        ASSIGN("glVertexAttribIPointer", vertexAttribIPointer);
        ASSIGN("glWaitSync", waitSync);
    }

    if (version >= gl::Version(3, 1))
    {
        ASSIGN("glActiveShaderProgram", activeShaderProgram);
        ASSIGN("glBindImageTexture", bindImageTexture);
        ASSIGN("glBindProgramPipeline", bindProgramPipeline);
        ASSIGN("glBindVertexBuffer", bindVertexBuffer);
        ASSIGN("glCreateShaderProgramv", createShaderProgramv);
        ASSIGN("glDeleteProgramPipelines", deleteProgramPipelines);
        ASSIGN("glDispatchCompute", dispatchCompute);
        ASSIGN("glDispatchComputeIndirect", dispatchComputeIndirect);
        ASSIGN("glDrawArraysIndirect", drawArraysIndirect);
        ASSIGN("glDrawElementsIndirect", drawElementsIndirect);
        ASSIGN("glFramebufferParameteri", framebufferParameteri);
        ASSIGN("glGenProgramPipelines", genProgramPipelines);
        ASSIGN("glGetBooleani_v", getBooleani_v);
        ASSIGN("glGetFramebufferParameteriv", getFramebufferParameteriv);
        ASSIGN("glGetMultisamplefv", getMultisamplefv);
        ASSIGN("glGetProgramInterfaceiv", getProgramInterfaceiv);
        ASSIGN("glGetProgramPipelineInfoLog", getProgramPipelineInfoLog);
        ASSIGN("glGetProgramPipelineiv", getProgramPipelineiv);
        ASSIGN("glGetProgramResourceIndex", getProgramResourceIndex);
        ASSIGN("glGetProgramResourceLocation", getProgramResourceLocation);
        ASSIGN("glGetProgramResourceName", getProgramResourceName);
        ASSIGN("glGetProgramResourceiv", getProgramResourceiv);
        ASSIGN("glGetTexLevelParameterfv", getTexLevelParameterfv);
        ASSIGN("glGetTexLevelParameteriv", getTexLevelParameteriv);
        ASSIGN("glIsProgramPipeline", isProgramPipeline);
        ASSIGN("glMemoryBarrier", memoryBarrier);
        ASSIGN("glMemoryBarrierByRegion", memoryBarrierByRegion);
        ASSIGN("glProgramUniform1f", programUniform1f);
        ASSIGN("glProgramUniform1fv", programUniform1fv);
        ASSIGN("glProgramUniform1i", programUniform1i);
        ASSIGN("glProgramUniform1iv", programUniform1iv);
        ASSIGN("glProgramUniform1ui", programUniform1ui);
        ASSIGN("glProgramUniform1uiv", programUniform1uiv);
        ASSIGN("glProgramUniform2f", programUniform2f);
        ASSIGN("glProgramUniform2fv", programUniform2fv);
        ASSIGN("glProgramUniform2i", programUniform2i);
        ASSIGN("glProgramUniform2iv", programUniform2iv);
        ASSIGN("glProgramUniform2ui", programUniform2ui);
        ASSIGN("glProgramUniform2uiv", programUniform2uiv);
        ASSIGN("glProgramUniform3f", programUniform3f);
        ASSIGN("glProgramUniform3fv", programUniform3fv);
        ASSIGN("glProgramUniform3i", programUniform3i);
        ASSIGN("glProgramUniform3iv", programUniform3iv);
        ASSIGN("glProgramUniform3ui", programUniform3ui);
        ASSIGN("glProgramUniform3uiv", programUniform3uiv);
        ASSIGN("glProgramUniform4f", programUniform4f);
        ASSIGN("glProgramUniform4fv", programUniform4fv);
        ASSIGN("glProgramUniform4i", programUniform4i);
        ASSIGN("glProgramUniform4iv", programUniform4iv);
        ASSIGN("glProgramUniform4ui", programUniform4ui);
        ASSIGN("glProgramUniform4uiv", programUniform4uiv);
        ASSIGN("glProgramUniformMatrix2fv", programUniformMatrix2fv);
        ASSIGN("glProgramUniformMatrix2x3fv", programUniformMatrix2x3fv);
        ASSIGN("glProgramUniformMatrix2x4fv", programUniformMatrix2x4fv);
        ASSIGN("glProgramUniformMatrix3fv", programUniformMatrix3fv);
        ASSIGN("glProgramUniformMatrix3x2fv", programUniformMatrix3x2fv);
        ASSIGN("glProgramUniformMatrix3x4fv", programUniformMatrix3x4fv);
        ASSIGN("glProgramUniformMatrix4fv", programUniformMatrix4fv);
        ASSIGN("glProgramUniformMatrix4x2fv", programUniformMatrix4x2fv);
        ASSIGN("glProgramUniformMatrix4x3fv", programUniformMatrix4x3fv);
        ASSIGN("glSampleMaski", sampleMaski);
        ASSIGN("glTexStorage2DMultisample", texStorage2DMultisample);
        ASSIGN("glUseProgramStages", useProgramStages);
        ASSIGN("glValidateProgramPipeline", validateProgramPipeline);
        ASSIGN("glVertexAttribBinding", vertexAttribBinding);
        ASSIGN("glVertexAttribFormat", vertexAttribFormat);
        ASSIGN("glVertexAttribIFormat", vertexAttribIFormat);
        ASSIGN("glVertexBindingDivisor", vertexBindingDivisor);
    }

    if (version >= gl::Version(3, 2))
    {
        ASSIGN("glBlendBarrier", blendBarrier);
        ASSIGN("glBlendEquationSeparatei", blendEquationSeparatei);
        ASSIGN("glBlendEquationi", blendEquationi);
        ASSIGN("glBlendFuncSeparatei", blendFuncSeparatei);
        ASSIGN("glBlendFunci", blendFunci);
        ASSIGN("glColorMaski", colorMaski);
        ASSIGN("glCopyImageSubData", copyImageSubData);
        ASSIGN("glDebugMessageCallback", debugMessageCallback);
        ASSIGN("glDebugMessageControl", debugMessageControl);
        ASSIGN("glDebugMessageInsert", debugMessageInsert);
        ASSIGN("glDisablei", disablei);
        ASSIGN("glDrawElementsBaseVertex", drawElementsBaseVertex);
        ASSIGN("glDrawElementsInstancedBaseVertex", drawElementsInstancedBaseVertex);
        ASSIGN("glDrawRangeElementsBaseVertex", drawRangeElementsBaseVertex);
        ASSIGN("glEnablei", enablei);
        ASSIGN("glFramebufferTexture", framebufferTexture);
        ASSIGN("glGetDebugMessageLog", getDebugMessageLog);
        ASSIGN("glGetGraphicsResetStatus", getGraphicsResetStatus);
        ASSIGN("glGetObjectLabel", getObjectLabel);
        ASSIGN("glGetObjectPtrLabel", getObjectPtrLabel);
        ASSIGN("glGetPointerv", getPointerv);
        ASSIGN("glGetSamplerParameterIiv", getSamplerParameterIiv);
        ASSIGN("glGetSamplerParameterIuiv", getSamplerParameterIuiv);
        ASSIGN("glGetTexParameterIiv", getTexParameterIiv);
        ASSIGN("glGetTexParameterIuiv", getTexParameterIuiv);
        ASSIGN("glGetnUniformfv", getnUniformfv);
        ASSIGN("glGetnUniformiv", getnUniformiv);
        ASSIGN("glGetnUniformuiv", getnUniformuiv);
        ASSIGN("glIsEnabledi", isEnabledi);
        ASSIGN("glMinSampleShading", minSampleShading);
        ASSIGN("glObjectLabel", objectLabel);
        ASSIGN("glObjectPtrLabel", objectPtrLabel);
        ASSIGN("glPatchParameteri", patchParameteri);
        ASSIGN("glPopDebugGroup", popDebugGroup);
        ASSIGN("glPrimitiveBoundingBox", primitiveBoundingBox);
        ASSIGN("glPushDebugGroup", pushDebugGroup);
        ASSIGN("glReadnPixels", readnPixels);
        ASSIGN("glSamplerParameterIiv", samplerParameterIiv);
        ASSIGN("glSamplerParameterIuiv", samplerParameterIuiv);
        ASSIGN("glTexBuffer", texBuffer);
        ASSIGN("glTexBufferRange", texBufferRange);
        ASSIGN("glTexParameterIiv", texParameterIiv);
        ASSIGN("glTexParameterIuiv", texParameterIuiv);
        ASSIGN("glTexStorage3DMultisample", texStorage3DMultisample);
    }

    if (extensions.count("GL_EXT_base_instance") != 0)
    {
        ASSIGN("glDrawArraysInstancedBaseInstanceEXT", drawArraysInstancedBaseInstance);
        ASSIGN("glDrawElementsInstancedBaseInstanceEXT", drawElementsInstancedBaseInstance);
        ASSIGN("glDrawElementsInstancedBaseVertexBaseInstanceEXT",
               drawElementsInstancedBaseVertexBaseInstance);
    }

    if (extensions.count("GL_EXT_blend_func_extended") != 0)
    {
        ASSIGN("glBindFragDataLocationEXT", bindFragDataLocation);
        ASSIGN("glBindFragDataLocationIndexedEXT", bindFragDataLocationIndexed);
        ASSIGN("glGetFragDataIndexEXT", getFragDataIndex);
        ASSIGN("glGetProgramResourceLocationIndexEXT", getProgramResourceLocationIndex);
    }

    if (extensions.count("GL_EXT_buffer_storage") != 0)
    {
        ASSIGN("glBufferStorageEXT", bufferStorage);
    }

    if (extensions.count("GL_EXT_clear_texture") != 0)
    {
        ASSIGN("glClearTexImageEXT", clearTexImage);
        ASSIGN("glClearTexSubImageEXT", clearTexSubImage);
    }

    if (extensions.count("GL_EXT_clip_control") != 0)
    {
        ASSIGN("glClipControlEXT", clipControl);
    }

    if (extensions.count("GL_EXT_copy_image") != 0)
    {
        ASSIGN("glCopyImageSubDataEXT", copyImageSubData);
    }

    if (extensions.count("GL_EXT_discard_framebuffer") != 0)
    {
        ASSIGN("glDiscardFramebufferEXT", discardFramebufferEXT);
    }

    if (extensions.count("GL_EXT_disjoint_timer_query") != 0)
    {
        ASSIGN("glBeginQueryEXT", beginQuery);
        ASSIGN("glDeleteQueriesEXT", deleteQueries);
        ASSIGN("glEndQueryEXT", endQuery);
        ASSIGN("glGenQueriesEXT", genQueries);
        ASSIGN("glGetQueryObjecti64vEXT", getQueryObjecti64v);
        ASSIGN("glGetQueryObjectivEXT", getQueryObjectiv);
        ASSIGN("glGetQueryObjectui64vEXT", getQueryObjectui64v);
        ASSIGN("glGetQueryObjectuivEXT", getQueryObjectuiv);
        ASSIGN("glGetQueryivEXT", getQueryiv);
        ASSIGN("glIsQueryEXT", isQuery);
        ASSIGN("glQueryCounterEXT", queryCounter);
    }

    if (extensions.count("GL_EXT_draw_buffers") != 0)
    {
        ASSIGN("glDrawBuffersEXT", drawBuffers);
    }

    if (extensions.count("GL_EXT_draw_buffers_indexed") != 0)
    {
        ASSIGN("glBlendEquationSeparateiEXT", blendEquationSeparatei);
        ASSIGN("glBlendEquationiEXT", blendEquationi);
        ASSIGN("glBlendFuncSeparateiEXT", blendFuncSeparatei);
        ASSIGN("glBlendFunciEXT", blendFunci);
        ASSIGN("glColorMaskiEXT", colorMaski);
        ASSIGN("glDisableiEXT", disablei);
        ASSIGN("glEnableiEXT", enablei);
        ASSIGN("glIsEnablediEXT", isEnabledi);
    }

    if (extensions.count("GL_EXT_draw_elements_base_vertex") != 0)
    {
        ASSIGN("glDrawElementsBaseVertexEXT", drawElementsBaseVertex);
        ASSIGN("glDrawElementsInstancedBaseVertexEXT", drawElementsInstancedBaseVertex);
        ASSIGN("glDrawRangeElementsBaseVertexEXT", drawRangeElementsBaseVertex);
        ASSIGN("glMultiDrawElementsBaseVertexEXT", multiDrawElementsBaseVertex);
    }

    if (extensions.count("GL_EXT_draw_transform_feedback") != 0)
    {
        ASSIGN("glDrawTransformFeedbackEXT", drawTransformFeedback);
        ASSIGN("glDrawTransformFeedbackInstancedEXT", drawTransformFeedbackInstanced);
    }

    if (extensions.count("GL_EXT_geometry_shader") != 0)
    {
        ASSIGN("glFramebufferTextureEXT", framebufferTexture);
    }

    if (extensions.count("GL_EXT_instanced_arrays") != 0)
    {
        ASSIGN("glVertexAttribDivisorEXT", vertexAttribDivisor);
    }

    if (extensions.count("GL_EXT_map_buffer_range") != 0)
    {
        ASSIGN("glFlushMappedBufferRangeEXT", flushMappedBufferRange);
        ASSIGN("glMapBufferRangeEXT", mapBufferRange);
    }

    if (extensions.count("GL_EXT_multi_draw_indirect") != 0)
    {
        ASSIGN("glMultiDrawArraysIndirectEXT", multiDrawArraysIndirect);
        ASSIGN("glMultiDrawElementsIndirectEXT", multiDrawElementsIndirect);
    }

    if (extensions.count("GL_EXT_multisampled_render_to_texture") != 0)
    {
        ASSIGN("glRenderbufferStorageMultisampleEXT", renderbufferStorageMultisample);
    }

    if (extensions.count("GL_EXT_multiview_draw_buffers") != 0)
    {
        ASSIGN("glGetIntegeri_vEXT", getIntegeri_v);
    }

    if (extensions.count("GL_EXT_occlusion_query_boolean") != 0)
    {
        ASSIGN("glBeginQueryEXT", beginQuery);
        ASSIGN("glDeleteQueriesEXT", deleteQueries);
        ASSIGN("glEndQueryEXT", endQuery);
        ASSIGN("glGenQueriesEXT", genQueries);
        ASSIGN("glGetQueryObjectuivEXT", getQueryObjectuiv);
        ASSIGN("glGetQueryivEXT", getQueryiv);
        ASSIGN("glIsQueryEXT", isQuery);
    }

    if (extensions.count("GL_EXT_primitive_bounding_box") != 0)
    {
        ASSIGN("glPrimitiveBoundingBoxEXT", primitiveBoundingBox);
    }

    if (extensions.count("GL_EXT_robustness") != 0)
    {
        ASSIGN("glGetGraphicsResetStatusEXT", getGraphicsResetStatus);
        ASSIGN("glGetnUniformfvEXT", getnUniformfv);
        ASSIGN("glGetnUniformivEXT", getnUniformiv);
        ASSIGN("glReadnPixelsEXT", readnPixels);
    }

    if (extensions.count("GL_EXT_tessellation_shader") != 0)
    {
        ASSIGN("glPatchParameteriEXT", patchParameteri);
    }

    if (extensions.count("GL_EXT_texture_border_clamp") != 0)
    {
        ASSIGN("glGetSamplerParameterIivEXT", getSamplerParameterIiv);
        ASSIGN("glGetSamplerParameterIuivEXT", getSamplerParameterIuiv);
        ASSIGN("glGetTexParameterIivEXT", getTexParameterIiv);
        ASSIGN("glGetTexParameterIuivEXT", getTexParameterIuiv);
        ASSIGN("glSamplerParameterIivEXT", samplerParameterIiv);
        ASSIGN("glSamplerParameterIuivEXT", samplerParameterIuiv);
        ASSIGN("glTexParameterIivEXT", texParameterIiv);
        ASSIGN("glTexParameterIuivEXT", texParameterIuiv);
    }

    if (extensions.count("GL_EXT_texture_buffer") != 0)
    {
        ASSIGN("glTexBufferEXT", texBuffer);
        ASSIGN("glTexBufferRangeEXT", texBufferRange);
    }

    if (extensions.count("GL_EXT_texture_storage") != 0)
    {
        ASSIGN("glTexStorage1DEXT", texStorage1D);
        ASSIGN("glTexStorage2DEXT", texStorage2D);
        ASSIGN("glTexStorage3DEXT", texStorage3D);
        ASSIGN("glTextureStorage1DEXT", textureStorage1D);
        ASSIGN("glTextureStorage2DEXT", textureStorage2D);
        ASSIGN("glTextureStorage3DEXT", textureStorage3D);
    }

    if (extensions.count("GL_EXT_texture_view") != 0)
    {
        ASSIGN("glTextureViewEXT", textureView);
    }

    if (extensions.count("GL_KHR_debug") != 0)
    {
        ASSIGN("glDebugMessageCallbackKHR", debugMessageCallback);
        ASSIGN("glDebugMessageControlKHR", debugMessageControl);
        ASSIGN("glDebugMessageInsertKHR", debugMessageInsert);
        ASSIGN("glGetDebugMessageLogKHR", getDebugMessageLog);
        ASSIGN("glGetObjectLabelKHR", getObjectLabel);
        ASSIGN("glGetObjectPtrLabelKHR", getObjectPtrLabel);
        ASSIGN("glGetPointervKHR", getPointerv);
        ASSIGN("glObjectLabelKHR", objectLabel);
        ASSIGN("glObjectPtrLabelKHR", objectPtrLabel);
        ASSIGN("glPopDebugGroupKHR", popDebugGroup);
        ASSIGN("glPushDebugGroupKHR", pushDebugGroup);
    }

    if (extensions.count("GL_KHR_robustness") != 0)
    {
        ASSIGN("glGetGraphicsResetStatusKHR", getGraphicsResetStatus);
        ASSIGN("glGetnUniformfvKHR", getnUniformfv);
        ASSIGN("glGetnUniformivKHR", getnUniformiv);
        ASSIGN("glGetnUniformuivKHR", getnUniformuiv);
        ASSIGN("glReadnPixelsKHR", readnPixels);
    }

    if (extensions.count("GL_OES_EGL_image") != 0)
    {
        ASSIGN("glEGLImageTargetRenderbufferStorageOES", eGLImageTargetRenderbufferStorageOES);
        ASSIGN("glEGLImageTargetTexture2DOES", eGLImageTargetTexture2DOES);
    }

    if (extensions.count("GL_OES_copy_image") != 0)
    {
        ASSIGN("glCopyImageSubDataOES", copyImageSubData);
    }

    if (extensions.count("GL_OES_draw_buffers_indexed") != 0)
    {
        ASSIGN("glBlendEquationSeparateiOES", blendEquationSeparatei);
        ASSIGN("glBlendEquationiOES", blendEquationi);
        ASSIGN("glBlendFuncSeparateiOES", blendFuncSeparatei);
        ASSIGN("glBlendFunciOES", blendFunci);
        ASSIGN("glColorMaskiOES", colorMaski);
        ASSIGN("glDisableiOES", disablei);
        ASSIGN("glEnableiOES", enablei);
        ASSIGN("glIsEnablediOES", isEnabledi);
    }

    if (extensions.count("GL_OES_draw_elements_base_vertex") != 0)
    {
        ASSIGN("glDrawElementsBaseVertexOES", drawElementsBaseVertex);
        ASSIGN("glDrawElementsInstancedBaseVertexOES", drawElementsInstancedBaseVertex);
        ASSIGN("glDrawRangeElementsBaseVertexOES", drawRangeElementsBaseVertex);
        ASSIGN("glMultiDrawElementsBaseVertexEXT", multiDrawElementsBaseVertex);
    }

    if (extensions.count("GL_OES_geometry_shader") != 0)
    {
        ASSIGN("glFramebufferTextureOES", framebufferTexture);
    }

    if (extensions.count("GL_OES_get_program_binary") != 0)
    {
        ASSIGN("glGetProgramBinaryOES", getProgramBinary);
        ASSIGN("glProgramBinaryOES", programBinary);
    }

    if (extensions.count("GL_OES_mapbuffer") != 0)
    {
        ASSIGN("glGetBufferPointervOES", getBufferPointerv);
        ASSIGN("glMapBufferOES", mapBuffer);
        ASSIGN("glUnmapBufferOES", unmapBuffer);
    }

    if (extensions.count("GL_OES_primitive_bounding_box") != 0)
    {
        ASSIGN("glPrimitiveBoundingBoxOES", primitiveBoundingBox);
    }

    if (extensions.count("GL_OES_sample_shading") != 0)
    {
        ASSIGN("glMinSampleShadingOES", minSampleShading);
    }

    if (extensions.count("GL_OES_tessellation_shader") != 0)
    {
        ASSIGN("glPatchParameteriOES", patchParameteri);
    }

    if (extensions.count("GL_OES_texture_3D") != 0)
    {
        ASSIGN("glCompressedTexImage3DOES", compressedTexImage3D);
        ASSIGN("glCompressedTexSubImage3DOES", compressedTexSubImage3D);
        ASSIGN("glCopyTexSubImage3DOES", copyTexSubImage3D);
        ASSIGN("glFramebufferTexture3DOES", framebufferTexture3D);
        ASSIGN("glTexImage3DOES", texImage3D);
        ASSIGN("glTexSubImage3DOES", texSubImage3D);
    }

    if (extensions.count("GL_OES_texture_border_clamp") != 0)
    {
        ASSIGN("glGetSamplerParameterIivOES", getSamplerParameterIiv);
        ASSIGN("glGetSamplerParameterIuivOES", getSamplerParameterIuiv);
        ASSIGN("glGetTexParameterIivOES", getTexParameterIiv);
        ASSIGN("glGetTexParameterIuivOES", getTexParameterIuiv);
        ASSIGN("glSamplerParameterIivOES", samplerParameterIiv);
        ASSIGN("glSamplerParameterIuivOES", samplerParameterIuiv);
        ASSIGN("glTexParameterIivOES", texParameterIiv);
        ASSIGN("glTexParameterIuivOES", texParameterIuiv);
    }

    if (extensions.count("GL_OES_texture_buffer") != 0)
    {
        ASSIGN("glTexBufferOES", texBuffer);
        ASSIGN("glTexBufferRangeOES", texBufferRange);
    }

    if (extensions.count("GL_OES_texture_storage_multisample_2d_array") != 0)
    {
        ASSIGN("glTexStorage3DMultisampleOES", texStorage3DMultisample);
    }

    if (extensions.count("GL_OES_texture_view") != 0)
    {
        ASSIGN("glTextureViewOES", textureView);
    }

    if (extensions.count("GL_OES_vertex_array_object") != 0)
    {
        ASSIGN("glBindVertexArrayOES", bindVertexArray);
        ASSIGN("glDeleteVertexArraysOES", deleteVertexArrays);
        ASSIGN("glGenVertexArraysOES", genVertexArrays);
        ASSIGN("glIsVertexArrayOES", isVertexArray);
    }

    if (extensions.count("GL_OES_viewport_array") != 0)
    {
        ASSIGN("glDisableiOES", disablei);
        ASSIGN("glEnableiOES", enablei);
        ASSIGN("glGetFloati_vOES", getFloati_v);
        ASSIGN("glIsEnablediOES", isEnabledi);
        ASSIGN("glScissorArrayvOES", scissorArrayv);
        ASSIGN("glScissorIndexedOES", scissorIndexed);
        ASSIGN("glScissorIndexedvOES", scissorIndexedv);
        ASSIGN("glViewportArrayvOES", viewportArrayv);
        ASSIGN("glViewportIndexedfOES", viewportIndexedf);
        ASSIGN("glViewportIndexedfvOES", viewportIndexedfv);
    }
}

void DispatchTableGL::initProcsSharedExtensions(const std::set<std::string> &extensions)
{
    if (extensions.count("GL_EXT_blend_minmax") != 0)
    {
        ASSIGN("glBlendEquationEXT", blendEquation);
    }

    if (extensions.count("GL_EXT_debug_label") != 0)
    {
        ASSIGN("glGetObjectLabelEXT", getObjectLabel);
    }

    if (extensions.count("GL_EXT_debug_marker") != 0)
    {
        ASSIGN("glInsertEventMarkerEXT", insertEventMarkerEXT);
        ASSIGN("glPopGroupMarkerEXT", popGroupMarkerEXT);
        ASSIGN("glPushGroupMarkerEXT", pushGroupMarkerEXT);
    }

    if (extensions.count("GL_EXT_draw_instanced") != 0)
    {
        ASSIGN("glDrawArraysInstancedEXT", drawArraysInstanced);
        ASSIGN("glDrawElementsInstancedEXT", drawElementsInstanced);
    }

    if (extensions.count("GL_EXT_memory_object") != 0)
    {
        ASSIGN("glBufferStorageMemEXT", bufferStorageMemEXT);
        ASSIGN("glCreateMemoryObjectsEXT", createMemoryObjectsEXT);
        ASSIGN("glDeleteMemoryObjectsEXT", deleteMemoryObjectsEXT);
        ASSIGN("glGetMemoryObjectParameterivEXT", getMemoryObjectParameterivEXT);
        ASSIGN("glGetUnsignedBytei_vEXT", getUnsignedBytei_vEXT);
        ASSIGN("glGetUnsignedBytevEXT", getUnsignedBytevEXT);
        ASSIGN("glIsMemoryObjectEXT", isMemoryObjectEXT);
        ASSIGN("glMemoryObjectParameterivEXT", memoryObjectParameterivEXT);
        ASSIGN("glNamedBufferStorageMemEXT", namedBufferStorageMemEXT);
        ASSIGN("glTexStorageMem2DEXT", texStorageMem2DEXT);
        ASSIGN("glTexStorageMem2DMultisampleEXT", texStorageMem2DMultisampleEXT);
        ASSIGN("glTexStorageMem3DEXT", texStorageMem3DEXT);
        ASSIGN("glTexStorageMem3DMultisampleEXT", texStorageMem3DMultisampleEXT);
        ASSIGN("glTextureStorageMem2DEXT", textureStorageMem2DEXT);
        ASSIGN("glTextureStorageMem2DMultisampleEXT", textureStorageMem2DMultisampleEXT);
        ASSIGN("glTextureStorageMem3DEXT", textureStorageMem3DEXT);
        ASSIGN("glTextureStorageMem3DMultisampleEXT", textureStorageMem3DMultisampleEXT);
    }

    if (extensions.count("GL_EXT_memory_object_fd") != 0)
    {
        ASSIGN("glImportMemoryFdEXT", importMemoryFdEXT);
    }

    if (extensions.count("GL_EXT_memory_object_win32") != 0)
    {
        ASSIGN("glImportMemoryWin32HandleEXT", importMemoryWin32HandleEXT);
        ASSIGN("glImportMemoryWin32NameEXT", importMemoryWin32NameEXT);
    }

    if (extensions.count("GL_EXT_multi_draw_arrays") != 0)
    {
        ASSIGN("glMultiDrawArraysEXT", multiDrawArrays);
        ASSIGN("glMultiDrawElementsEXT", multiDrawElements);
    }

    if (extensions.count("GL_EXT_semaphore") != 0)
    {
        ASSIGN("glDeleteSemaphoresEXT", deleteSemaphoresEXT);
        ASSIGN("glGenSemaphoresEXT", genSemaphoresEXT);
        ASSIGN("glGetSemaphoreParameterui64vEXT", getSemaphoreParameterui64vEXT);
        ASSIGN("glGetUnsignedBytei_vEXT", getUnsignedBytei_vEXT);
        ASSIGN("glGetUnsignedBytevEXT", getUnsignedBytevEXT);
        ASSIGN("glIsSemaphoreEXT", isSemaphoreEXT);
        ASSIGN("glSemaphoreParameterui64vEXT", semaphoreParameterui64vEXT);
        ASSIGN("glSignalSemaphoreEXT", signalSemaphoreEXT);
        ASSIGN("glWaitSemaphoreEXT", waitSemaphoreEXT);
    }

    if (extensions.count("GL_EXT_semaphore_fd") != 0)
    {
        ASSIGN("glImportSemaphoreFdEXT", importSemaphoreFdEXT);
    }

    if (extensions.count("GL_EXT_semaphore_win32") != 0)
    {
        ASSIGN("glImportSemaphoreWin32HandleEXT", importSemaphoreWin32HandleEXT);
        ASSIGN("glImportSemaphoreWin32NameEXT", importSemaphoreWin32NameEXT);
    }

    if (extensions.count("GL_EXT_separate_shader_objects") != 0)
    {
        ASSIGN("glActiveShaderProgramEXT", activeShaderProgram);
        ASSIGN("glBindProgramPipelineEXT", bindProgramPipeline);
        ASSIGN("glCreateShaderProgramvEXT", createShaderProgramv);
        ASSIGN("glDeleteProgramPipelinesEXT", deleteProgramPipelines);
        ASSIGN("glGenProgramPipelinesEXT", genProgramPipelines);
        ASSIGN("glGetProgramPipelineInfoLogEXT", getProgramPipelineInfoLog);
        ASSIGN("glGetProgramPipelineivEXT", getProgramPipelineiv);
        ASSIGN("glIsProgramPipelineEXT", isProgramPipeline);
        ASSIGN("glProgramParameteriEXT", programParameteri);
        ASSIGN("glProgramUniform1fEXT", programUniform1f);
        ASSIGN("glProgramUniform1fvEXT", programUniform1fv);
        ASSIGN("glProgramUniform1iEXT", programUniform1i);
        ASSIGN("glProgramUniform1ivEXT", programUniform1iv);
        ASSIGN("glProgramUniform1uiEXT", programUniform1ui);
        ASSIGN("glProgramUniform1uivEXT", programUniform1uiv);
        ASSIGN("glProgramUniform2fEXT", programUniform2f);
        ASSIGN("glProgramUniform2fvEXT", programUniform2fv);
        ASSIGN("glProgramUniform2iEXT", programUniform2i);
        ASSIGN("glProgramUniform2ivEXT", programUniform2iv);
        ASSIGN("glProgramUniform2uiEXT", programUniform2ui);
        ASSIGN("glProgramUniform2uivEXT", programUniform2uiv);
        ASSIGN("glProgramUniform3fEXT", programUniform3f);
        ASSIGN("glProgramUniform3fvEXT", programUniform3fv);
        ASSIGN("glProgramUniform3iEXT", programUniform3i);
        ASSIGN("glProgramUniform3ivEXT", programUniform3iv);
        ASSIGN("glProgramUniform3uiEXT", programUniform3ui);
        ASSIGN("glProgramUniform3uivEXT", programUniform3uiv);
        ASSIGN("glProgramUniform4fEXT", programUniform4f);
        ASSIGN("glProgramUniform4fvEXT", programUniform4fv);
        ASSIGN("glProgramUniform4iEXT", programUniform4i);
        ASSIGN("glProgramUniform4ivEXT", programUniform4iv);
        ASSIGN("glProgramUniform4uiEXT", programUniform4ui);
        ASSIGN("glProgramUniform4uivEXT", programUniform4uiv);
        ASSIGN("glProgramUniformMatrix2fvEXT", programUniformMatrix2fv);
        ASSIGN("glProgramUniformMatrix2x3fvEXT", programUniformMatrix2x3fv);
        ASSIGN("glProgramUniformMatrix2x4fvEXT", programUniformMatrix2x4fv);
        ASSIGN("glProgramUniformMatrix3fvEXT", programUniformMatrix3fv);
        ASSIGN("glProgramUniformMatrix3x2fvEXT", programUniformMatrix3x2fv);
        ASSIGN("glProgramUniformMatrix3x4fvEXT", programUniformMatrix3x4fv);
        ASSIGN("glProgramUniformMatrix4fvEXT", programUniformMatrix4fv);
        ASSIGN("glProgramUniformMatrix4fvEXT", programUniformMatrix4fv);
        ASSIGN("glProgramUniformMatrix4x2fvEXT", programUniformMatrix4x2fv);
        ASSIGN("glProgramUniformMatrix4x3fvEXT", programUniformMatrix4x3fv);
        ASSIGN("glUseProgramStagesEXT", useProgramStages);
        ASSIGN("glValidateProgramPipelineEXT", validateProgramPipeline);
    }

    if (extensions.count("GL_KHR_parallel_shader_compile") != 0)
    {
        ASSIGN("glMaxShaderCompilerThreadsKHR", maxShaderCompilerThreadsKHR);
    }

    if (extensions.count("GL_NV_fence") != 0)
    {
        ASSIGN("glDeleteFencesNV", deleteFencesNV);
        ASSIGN("glFinishFenceNV", finishFenceNV);
        ASSIGN("glGenFencesNV", genFencesNV);
        ASSIGN("glGetFenceivNV", getFenceivNV);
        ASSIGN("glIsFenceNV", isFenceNV);
        ASSIGN("glSetFenceNV", setFenceNV);
        ASSIGN("glTestFenceNV", testFenceNV);
    }

    if (extensions.count("GL_NV_framebuffer_mixed_samples") != 0)
    {
        ASSIGN("glCoverageModulationNV", coverageModulationNV);
    }

    if (extensions.count("GL_NV_internalformat_sample_query") != 0)
    {
        ASSIGN("glGetInternalformatSampleivNV", getInternalformatSampleivNV);
    }

    if (extensions.count("GL_NV_path_rendering") != 0)
    {
        ASSIGN("glCoverFillPathInstancedNV", coverFillPathInstancedNV);
        ASSIGN("glCoverFillPathNV", coverFillPathNV);
        ASSIGN("glCoverStrokePathInstancedNV", coverStrokePathInstancedNV);
        ASSIGN("glCoverStrokePathNV", coverStrokePathNV);
        ASSIGN("glDeletePathsNV", deletePathsNV);
        ASSIGN("glGenPathsNV", genPathsNV);
        ASSIGN("glGetPathParameterfvNV", getPathParameterfvNV);
        ASSIGN("glGetPathParameterivNV", getPathParameterivNV);
        ASSIGN("glIsPathNV", isPathNV);
        ASSIGN("glMatrixLoadfEXT", matrixLoadfEXT);
        ASSIGN("glPathCommandsNV", pathCommandsNV);
        ASSIGN("glPathParameterfNV", pathParameterfNV);
        ASSIGN("glPathParameteriNV", pathParameteriNV);
        ASSIGN("glPathStencilFuncNV", pathStencilFuncNV);
        ASSIGN("glProgramPathFragmentInputGenNV", programPathFragmentInputGenNV);
        ASSIGN("glStencilFillPathInstancedNV", stencilFillPathInstancedNV);
        ASSIGN("glStencilFillPathNV", stencilFillPathNV);
        ASSIGN("glStencilStrokePathInstancedNV", stencilStrokePathInstancedNV);
        ASSIGN("glStencilStrokePathNV", stencilStrokePathNV);
        ASSIGN("glStencilThenCoverFillPathInstancedNV", stencilThenCoverFillPathInstancedNV);
        ASSIGN("glStencilThenCoverFillPathNV", stencilThenCoverFillPathNV);
        ASSIGN("glStencilThenCoverStrokePathInstancedNV", stencilThenCoverStrokePathInstancedNV);
        ASSIGN("glStencilThenCoverStrokePathNV", stencilThenCoverStrokePathNV);
    }

    if (extensions.count("GL_OVR_multiview") != 0)
    {
        ASSIGN("glFramebufferTextureMultiviewOVR", framebufferTextureMultiviewOVR);
    }
}

#if defined(ANGLE_ENABLE_OPENGL_NULL)
void DispatchTableGL::initProcsDesktopGLNULL(const gl::Version &version,
                                             const std::set<std::string> &extensions)
{
    if (version >= gl::Version(1, 0))
    {
        blendFunc              = &glBlendFuncNULL;
        clear                  = &glClearNULL;
        clearColor             = &glClearColorNULL;
        clearDepth             = &glClearDepthNULL;
        clearStencil           = &glClearStencilNULL;
        colorMask              = &glColorMaskNULL;
        cullFace               = &glCullFaceNULL;
        depthFunc              = &glDepthFuncNULL;
        depthMask              = &glDepthMaskNULL;
        depthRange             = &glDepthRangeNULL;
        disable                = &glDisableNULL;
        drawBuffer             = &glDrawBufferNULL;
        enable                 = &glEnableNULL;
        finish                 = &glFinishNULL;
        flush                  = &glFlushNULL;
        frontFace              = &glFrontFaceNULL;
        getBooleanv            = &glGetBooleanvNULL;
        getDoublev             = &glGetDoublevNULL;
        getError               = &glGetErrorNULL;
        getFloatv              = &glGetFloatvNULL;
        getIntegerv            = &glGetIntegervNULL;
        getString              = &glGetStringNULL;
        getTexImage            = &glGetTexImageNULL;
        getTexLevelParameterfv = &glGetTexLevelParameterfvNULL;
        getTexLevelParameteriv = &glGetTexLevelParameterivNULL;
        getTexParameterfv      = &glGetTexParameterfvNULL;
        getTexParameteriv      = &glGetTexParameterivNULL;
        hint                   = &glHintNULL;
        isEnabled              = &glIsEnabledNULL;
        lineWidth              = &glLineWidthNULL;
        logicOp                = &glLogicOpNULL;
        pixelStoref            = &glPixelStorefNULL;
        pixelStorei            = &glPixelStoreiNULL;
        pointSize              = &glPointSizeNULL;
        polygonMode            = &glPolygonModeNULL;
        readBuffer             = &glReadBufferNULL;
        readPixels             = &glReadPixelsNULL;
        scissor                = &glScissorNULL;
        stencilFunc            = &glStencilFuncNULL;
        stencilMask            = &glStencilMaskNULL;
        stencilOp              = &glStencilOpNULL;
        texImage1D             = &glTexImage1DNULL;
        texImage2D             = &glTexImage2DNULL;
        texParameterf          = &glTexParameterfNULL;
        texParameterfv         = &glTexParameterfvNULL;
        texParameteri          = &glTexParameteriNULL;
        texParameteriv         = &glTexParameterivNULL;
        viewport               = &glViewportNULL;
    }

    if (version >= gl::Version(1, 1))
    {
        bindTexture       = &glBindTextureNULL;
        copyTexImage1D    = &glCopyTexImage1DNULL;
        copyTexImage2D    = &glCopyTexImage2DNULL;
        copyTexSubImage1D = &glCopyTexSubImage1DNULL;
        copyTexSubImage2D = &glCopyTexSubImage2DNULL;
        deleteTextures    = &glDeleteTexturesNULL;
        drawArrays        = &glDrawArraysNULL;
        drawElements      = &glDrawElementsNULL;
        genTextures       = &glGenTexturesNULL;
        isTexture         = &glIsTextureNULL;
        polygonOffset     = &glPolygonOffsetNULL;
        texSubImage1D     = &glTexSubImage1DNULL;
        texSubImage2D     = &glTexSubImage2DNULL;
    }

    if (version >= gl::Version(1, 2))
    {
        copyTexSubImage3D = &glCopyTexSubImage3DNULL;
        drawRangeElements = &glDrawRangeElementsNULL;
        texImage3D        = &glTexImage3DNULL;
        texSubImage3D     = &glTexSubImage3DNULL;
    }

    if (version >= gl::Version(1, 3))
    {
        activeTexture           = &glActiveTextureNULL;
        compressedTexImage1D    = &glCompressedTexImage1DNULL;
        compressedTexImage2D    = &glCompressedTexImage2DNULL;
        compressedTexImage3D    = &glCompressedTexImage3DNULL;
        compressedTexSubImage1D = &glCompressedTexSubImage1DNULL;
        compressedTexSubImage2D = &glCompressedTexSubImage2DNULL;
        compressedTexSubImage3D = &glCompressedTexSubImage3DNULL;
        getCompressedTexImage   = &glGetCompressedTexImageNULL;
        sampleCoverage          = &glSampleCoverageNULL;
    }

    if (version >= gl::Version(1, 4))
    {
        blendColor        = &glBlendColorNULL;
        blendEquation     = &glBlendEquationNULL;
        blendFuncSeparate = &glBlendFuncSeparateNULL;
        multiDrawArrays   = &glMultiDrawArraysNULL;
        multiDrawElements = &glMultiDrawElementsNULL;
        pointParameterf   = &glPointParameterfNULL;
        pointParameterfv  = &glPointParameterfvNULL;
        pointParameteri   = &glPointParameteriNULL;
        pointParameteriv  = &glPointParameterivNULL;
    }

    if (version >= gl::Version(1, 5))
    {
        beginQuery           = &glBeginQueryNULL;
        bindBuffer           = &glBindBufferNULL;
        bufferData           = &glBufferDataNULL;
        bufferSubData        = &glBufferSubDataNULL;
        deleteBuffers        = &glDeleteBuffersNULL;
        deleteQueries        = &glDeleteQueriesNULL;
        endQuery             = &glEndQueryNULL;
        genBuffers           = &glGenBuffersNULL;
        genQueries           = &glGenQueriesNULL;
        getBufferParameteriv = &glGetBufferParameterivNULL;
        getBufferPointerv    = &glGetBufferPointervNULL;
        getBufferSubData     = &glGetBufferSubDataNULL;
        getQueryObjectiv     = &glGetQueryObjectivNULL;
        getQueryObjectuiv    = &glGetQueryObjectuivNULL;
        getQueryiv           = &glGetQueryivNULL;
        isBuffer             = &glIsBufferNULL;
        isQuery              = &glIsQueryNULL;
        mapBuffer            = &glMapBufferNULL;
        unmapBuffer          = &glUnmapBufferNULL;
    }

    if (version >= gl::Version(2, 0))
    {
        attachShader             = &glAttachShaderNULL;
        bindAttribLocation       = &glBindAttribLocationNULL;
        blendEquationSeparate    = &glBlendEquationSeparateNULL;
        compileShader            = &glCompileShaderNULL;
        createProgram            = &glCreateProgramNULL;
        createShader             = &glCreateShaderNULL;
        deleteProgram            = &glDeleteProgramNULL;
        deleteShader             = &glDeleteShaderNULL;
        detachShader             = &glDetachShaderNULL;
        disableVertexAttribArray = &glDisableVertexAttribArrayNULL;
        drawBuffers              = &glDrawBuffersNULL;
        enableVertexAttribArray  = &glEnableVertexAttribArrayNULL;
        getActiveAttrib          = &glGetActiveAttribNULL;
        getActiveUniform         = &glGetActiveUniformNULL;
        getAttachedShaders       = &glGetAttachedShadersNULL;
        getAttribLocation        = &glGetAttribLocationNULL;
        getProgramInfoLog        = &glGetProgramInfoLogNULL;
        getProgramiv             = &glGetProgramivNULL;
        getShaderInfoLog         = &glGetShaderInfoLogNULL;
        getShaderSource          = &glGetShaderSourceNULL;
        getShaderiv              = &glGetShaderivNULL;
        getUniformLocation       = &glGetUniformLocationNULL;
        getUniformfv             = &glGetUniformfvNULL;
        getUniformiv             = &glGetUniformivNULL;
        getVertexAttribPointerv  = &glGetVertexAttribPointervNULL;
        getVertexAttribdv        = &glGetVertexAttribdvNULL;
        getVertexAttribfv        = &glGetVertexAttribfvNULL;
        getVertexAttribiv        = &glGetVertexAttribivNULL;
        isProgram                = &glIsProgramNULL;
        isShader                 = &glIsShaderNULL;
        linkProgram              = &glLinkProgramNULL;
        shaderSource             = &glShaderSourceNULL;
        stencilFuncSeparate      = &glStencilFuncSeparateNULL;
        stencilMaskSeparate      = &glStencilMaskSeparateNULL;
        stencilOpSeparate        = &glStencilOpSeparateNULL;
        uniform1f                = &glUniform1fNULL;
        uniform1fv               = &glUniform1fvNULL;
        uniform1i                = &glUniform1iNULL;
        uniform1iv               = &glUniform1ivNULL;
        uniform2f                = &glUniform2fNULL;
        uniform2fv               = &glUniform2fvNULL;
        uniform2i                = &glUniform2iNULL;
        uniform2iv               = &glUniform2ivNULL;
        uniform3f                = &glUniform3fNULL;
        uniform3fv               = &glUniform3fvNULL;
        uniform3i                = &glUniform3iNULL;
        uniform3iv               = &glUniform3ivNULL;
        uniform4f                = &glUniform4fNULL;
        uniform4fv               = &glUniform4fvNULL;
        uniform4i                = &glUniform4iNULL;
        uniform4iv               = &glUniform4ivNULL;
        uniformMatrix2fv         = &glUniformMatrix2fvNULL;
        uniformMatrix3fv         = &glUniformMatrix3fvNULL;
        uniformMatrix4fv         = &glUniformMatrix4fvNULL;
        useProgram               = &glUseProgramNULL;
        validateProgram          = &glValidateProgramNULL;
        vertexAttrib1d           = &glVertexAttrib1dNULL;
        vertexAttrib1dv          = &glVertexAttrib1dvNULL;
        vertexAttrib1f           = &glVertexAttrib1fNULL;
        vertexAttrib1fv          = &glVertexAttrib1fvNULL;
        vertexAttrib1s           = &glVertexAttrib1sNULL;
        vertexAttrib1sv          = &glVertexAttrib1svNULL;
        vertexAttrib2d           = &glVertexAttrib2dNULL;
        vertexAttrib2dv          = &glVertexAttrib2dvNULL;
        vertexAttrib2f           = &glVertexAttrib2fNULL;
        vertexAttrib2fv          = &glVertexAttrib2fvNULL;
        vertexAttrib2s           = &glVertexAttrib2sNULL;
        vertexAttrib2sv          = &glVertexAttrib2svNULL;
        vertexAttrib3d           = &glVertexAttrib3dNULL;
        vertexAttrib3dv          = &glVertexAttrib3dvNULL;
        vertexAttrib3f           = &glVertexAttrib3fNULL;
        vertexAttrib3fv          = &glVertexAttrib3fvNULL;
        vertexAttrib3s           = &glVertexAttrib3sNULL;
        vertexAttrib3sv          = &glVertexAttrib3svNULL;
        vertexAttrib4Nbv         = &glVertexAttrib4NbvNULL;
        vertexAttrib4Niv         = &glVertexAttrib4NivNULL;
        vertexAttrib4Nsv         = &glVertexAttrib4NsvNULL;
        vertexAttrib4Nub         = &glVertexAttrib4NubNULL;
        vertexAttrib4Nubv        = &glVertexAttrib4NubvNULL;
        vertexAttrib4Nuiv        = &glVertexAttrib4NuivNULL;
        vertexAttrib4Nusv        = &glVertexAttrib4NusvNULL;
        vertexAttrib4bv          = &glVertexAttrib4bvNULL;
        vertexAttrib4d           = &glVertexAttrib4dNULL;
        vertexAttrib4dv          = &glVertexAttrib4dvNULL;
        vertexAttrib4f           = &glVertexAttrib4fNULL;
        vertexAttrib4fv          = &glVertexAttrib4fvNULL;
        vertexAttrib4iv          = &glVertexAttrib4ivNULL;
        vertexAttrib4s           = &glVertexAttrib4sNULL;
        vertexAttrib4sv          = &glVertexAttrib4svNULL;
        vertexAttrib4ubv         = &glVertexAttrib4ubvNULL;
        vertexAttrib4uiv         = &glVertexAttrib4uivNULL;
        vertexAttrib4usv         = &glVertexAttrib4usvNULL;
        vertexAttribPointer      = &glVertexAttribPointerNULL;
    }

    if (version >= gl::Version(2, 1))
    {
        uniformMatrix2x3fv = &glUniformMatrix2x3fvNULL;
        uniformMatrix2x4fv = &glUniformMatrix2x4fvNULL;
        uniformMatrix3x2fv = &glUniformMatrix3x2fvNULL;
        uniformMatrix3x4fv = &glUniformMatrix3x4fvNULL;
        uniformMatrix4x2fv = &glUniformMatrix4x2fvNULL;
        uniformMatrix4x3fv = &glUniformMatrix4x3fvNULL;
    }

    if (version >= gl::Version(3, 0))
    {
        beginConditionalRender              = &glBeginConditionalRenderNULL;
        beginTransformFeedback              = &glBeginTransformFeedbackNULL;
        bindBufferBase                      = &glBindBufferBaseNULL;
        bindBufferRange                     = &glBindBufferRangeNULL;
        bindFragDataLocation                = &glBindFragDataLocationNULL;
        bindFramebuffer                     = &glBindFramebufferNULL;
        bindRenderbuffer                    = &glBindRenderbufferNULL;
        bindVertexArray                     = &glBindVertexArrayNULL;
        blitFramebuffer                     = &glBlitFramebufferNULL;
        checkFramebufferStatus              = &glCheckFramebufferStatusNULL;
        clampColor                          = &glClampColorNULL;
        clearBufferfi                       = &glClearBufferfiNULL;
        clearBufferfv                       = &glClearBufferfvNULL;
        clearBufferiv                       = &glClearBufferivNULL;
        clearBufferuiv                      = &glClearBufferuivNULL;
        colorMaski                          = &glColorMaskiNULL;
        deleteFramebuffers                  = &glDeleteFramebuffersNULL;
        deleteRenderbuffers                 = &glDeleteRenderbuffersNULL;
        deleteVertexArrays                  = &glDeleteVertexArraysNULL;
        disablei                            = &glDisableiNULL;
        enablei                             = &glEnableiNULL;
        endConditionalRender                = &glEndConditionalRenderNULL;
        endTransformFeedback                = &glEndTransformFeedbackNULL;
        flushMappedBufferRange              = &glFlushMappedBufferRangeNULL;
        framebufferRenderbuffer             = &glFramebufferRenderbufferNULL;
        framebufferTexture1D                = &glFramebufferTexture1DNULL;
        framebufferTexture2D                = &glFramebufferTexture2DNULL;
        framebufferTexture3D                = &glFramebufferTexture3DNULL;
        framebufferTextureLayer             = &glFramebufferTextureLayerNULL;
        genFramebuffers                     = &glGenFramebuffersNULL;
        genRenderbuffers                    = &glGenRenderbuffersNULL;
        genVertexArrays                     = &glGenVertexArraysNULL;
        generateMipmap                      = &glGenerateMipmapNULL;
        getBooleani_v                       = &glGetBooleani_vNULL;
        getFragDataLocation                 = &glGetFragDataLocationNULL;
        getFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameterivNULL;
        getIntegeri_v                       = &glGetIntegeri_vNULL;
        getRenderbufferParameteriv          = &glGetRenderbufferParameterivNULL;
        getStringi                          = &glGetStringiNULL;
        getTexParameterIiv                  = &glGetTexParameterIivNULL;
        getTexParameterIuiv                 = &glGetTexParameterIuivNULL;
        getTransformFeedbackVarying         = &glGetTransformFeedbackVaryingNULL;
        getUniformuiv                       = &glGetUniformuivNULL;
        getVertexAttribIiv                  = &glGetVertexAttribIivNULL;
        getVertexAttribIuiv                 = &glGetVertexAttribIuivNULL;
        isEnabledi                          = &glIsEnablediNULL;
        isFramebuffer                       = &glIsFramebufferNULL;
        isRenderbuffer                      = &glIsRenderbufferNULL;
        isVertexArray                       = &glIsVertexArrayNULL;
        mapBufferRange                      = &glMapBufferRangeNULL;
        renderbufferStorage                 = &glRenderbufferStorageNULL;
        renderbufferStorageMultisample      = &glRenderbufferStorageMultisampleNULL;
        texParameterIiv                     = &glTexParameterIivNULL;
        texParameterIuiv                    = &glTexParameterIuivNULL;
        transformFeedbackVaryings           = &glTransformFeedbackVaryingsNULL;
        uniform1ui                          = &glUniform1uiNULL;
        uniform1uiv                         = &glUniform1uivNULL;
        uniform2ui                          = &glUniform2uiNULL;
        uniform2uiv                         = &glUniform2uivNULL;
        uniform3ui                          = &glUniform3uiNULL;
        uniform3uiv                         = &glUniform3uivNULL;
        uniform4ui                          = &glUniform4uiNULL;
        uniform4uiv                         = &glUniform4uivNULL;
        vertexAttribI1i                     = &glVertexAttribI1iNULL;
        vertexAttribI1iv                    = &glVertexAttribI1ivNULL;
        vertexAttribI1ui                    = &glVertexAttribI1uiNULL;
        vertexAttribI1uiv                   = &glVertexAttribI1uivNULL;
        vertexAttribI2i                     = &glVertexAttribI2iNULL;
        vertexAttribI2iv                    = &glVertexAttribI2ivNULL;
        vertexAttribI2ui                    = &glVertexAttribI2uiNULL;
        vertexAttribI2uiv                   = &glVertexAttribI2uivNULL;
        vertexAttribI3i                     = &glVertexAttribI3iNULL;
        vertexAttribI3iv                    = &glVertexAttribI3ivNULL;
        vertexAttribI3ui                    = &glVertexAttribI3uiNULL;
        vertexAttribI3uiv                   = &glVertexAttribI3uivNULL;
        vertexAttribI4bv                    = &glVertexAttribI4bvNULL;
        vertexAttribI4i                     = &glVertexAttribI4iNULL;
        vertexAttribI4iv                    = &glVertexAttribI4ivNULL;
        vertexAttribI4sv                    = &glVertexAttribI4svNULL;
        vertexAttribI4ubv                   = &glVertexAttribI4ubvNULL;
        vertexAttribI4ui                    = &glVertexAttribI4uiNULL;
        vertexAttribI4uiv                   = &glVertexAttribI4uivNULL;
        vertexAttribI4usv                   = &glVertexAttribI4usvNULL;
        vertexAttribIPointer                = &glVertexAttribIPointerNULL;
    }

    if (version >= gl::Version(3, 1))
    {
        copyBufferSubData         = &glCopyBufferSubDataNULL;
        drawArraysInstanced       = &glDrawArraysInstancedNULL;
        drawElementsInstanced     = &glDrawElementsInstancedNULL;
        getActiveUniformBlockName = &glGetActiveUniformBlockNameNULL;
        getActiveUniformBlockiv   = &glGetActiveUniformBlockivNULL;
        getActiveUniformName      = &glGetActiveUniformNameNULL;
        getActiveUniformsiv       = &glGetActiveUniformsivNULL;
        getUniformBlockIndex      = &glGetUniformBlockIndexNULL;
        getUniformIndices         = &glGetUniformIndicesNULL;
        primitiveRestartIndex     = &glPrimitiveRestartIndexNULL;
        texBuffer                 = &glTexBufferNULL;
        uniformBlockBinding       = &glUniformBlockBindingNULL;
    }

    if (version >= gl::Version(3, 2))
    {
        clientWaitSync                  = &glClientWaitSyncNULL;
        deleteSync                      = &glDeleteSyncNULL;
        drawElementsBaseVertex          = &glDrawElementsBaseVertexNULL;
        drawElementsInstancedBaseVertex = &glDrawElementsInstancedBaseVertexNULL;
        drawRangeElementsBaseVertex     = &glDrawRangeElementsBaseVertexNULL;
        fenceSync                       = &glFenceSyncNULL;
        framebufferTexture              = &glFramebufferTextureNULL;
        getBufferParameteri64v          = &glGetBufferParameteri64vNULL;
        getInteger64i_v                 = &glGetInteger64i_vNULL;
        getInteger64v                   = &glGetInteger64vNULL;
        getMultisamplefv                = &glGetMultisamplefvNULL;
        getSynciv                       = &glGetSyncivNULL;
        isSync                          = &glIsSyncNULL;
        multiDrawElementsBaseVertex     = &glMultiDrawElementsBaseVertexNULL;
        provokingVertex                 = &glProvokingVertexNULL;
        sampleMaski                     = &glSampleMaskiNULL;
        texImage2DMultisample           = &glTexImage2DMultisampleNULL;
        texImage3DMultisample           = &glTexImage3DMultisampleNULL;
        waitSync                        = &glWaitSyncNULL;
    }

    if (version >= gl::Version(3, 3))
    {
        bindFragDataLocationIndexed = &glBindFragDataLocationIndexedNULL;
        bindSampler                 = &glBindSamplerNULL;
        deleteSamplers              = &glDeleteSamplersNULL;
        genSamplers                 = &glGenSamplersNULL;
        getFragDataIndex            = &glGetFragDataIndexNULL;
        getQueryObjecti64v          = &glGetQueryObjecti64vNULL;
        getQueryObjectui64v         = &glGetQueryObjectui64vNULL;
        getSamplerParameterIiv      = &glGetSamplerParameterIivNULL;
        getSamplerParameterIuiv     = &glGetSamplerParameterIuivNULL;
        getSamplerParameterfv       = &glGetSamplerParameterfvNULL;
        getSamplerParameteriv       = &glGetSamplerParameterivNULL;
        isSampler                   = &glIsSamplerNULL;
        queryCounter                = &glQueryCounterNULL;
        samplerParameterIiv         = &glSamplerParameterIivNULL;
        samplerParameterIuiv        = &glSamplerParameterIuivNULL;
        samplerParameterf           = &glSamplerParameterfNULL;
        samplerParameterfv          = &glSamplerParameterfvNULL;
        samplerParameteri           = &glSamplerParameteriNULL;
        samplerParameteriv          = &glSamplerParameterivNULL;
        vertexAttribDivisor         = &glVertexAttribDivisorNULL;
        vertexAttribP1ui            = &glVertexAttribP1uiNULL;
        vertexAttribP1uiv           = &glVertexAttribP1uivNULL;
        vertexAttribP2ui            = &glVertexAttribP2uiNULL;
        vertexAttribP2uiv           = &glVertexAttribP2uivNULL;
        vertexAttribP3ui            = &glVertexAttribP3uiNULL;
        vertexAttribP3uiv           = &glVertexAttribP3uivNULL;
        vertexAttribP4ui            = &glVertexAttribP4uiNULL;
        vertexAttribP4uiv           = &glVertexAttribP4uivNULL;
    }

    if (version >= gl::Version(4, 0))
    {
        beginQueryIndexed              = &glBeginQueryIndexedNULL;
        bindTransformFeedback          = &glBindTransformFeedbackNULL;
        blendEquationSeparatei         = &glBlendEquationSeparateiNULL;
        blendEquationi                 = &glBlendEquationiNULL;
        blendFuncSeparatei             = &glBlendFuncSeparateiNULL;
        blendFunci                     = &glBlendFunciNULL;
        deleteTransformFeedbacks       = &glDeleteTransformFeedbacksNULL;
        drawArraysIndirect             = &glDrawArraysIndirectNULL;
        drawElementsIndirect           = &glDrawElementsIndirectNULL;
        drawTransformFeedback          = &glDrawTransformFeedbackNULL;
        drawTransformFeedbackStream    = &glDrawTransformFeedbackStreamNULL;
        endQueryIndexed                = &glEndQueryIndexedNULL;
        genTransformFeedbacks          = &glGenTransformFeedbacksNULL;
        getActiveSubroutineName        = &glGetActiveSubroutineNameNULL;
        getActiveSubroutineUniformName = &glGetActiveSubroutineUniformNameNULL;
        getActiveSubroutineUniformiv   = &glGetActiveSubroutineUniformivNULL;
        getProgramStageiv              = &glGetProgramStageivNULL;
        getQueryIndexediv              = &glGetQueryIndexedivNULL;
        getSubroutineIndex             = &glGetSubroutineIndexNULL;
        getSubroutineUniformLocation   = &glGetSubroutineUniformLocationNULL;
        getUniformSubroutineuiv        = &glGetUniformSubroutineuivNULL;
        getUniformdv                   = &glGetUniformdvNULL;
        isTransformFeedback            = &glIsTransformFeedbackNULL;
        minSampleShading               = &glMinSampleShadingNULL;
        patchParameterfv               = &glPatchParameterfvNULL;
        patchParameteri                = &glPatchParameteriNULL;
        pauseTransformFeedback         = &glPauseTransformFeedbackNULL;
        resumeTransformFeedback        = &glResumeTransformFeedbackNULL;
        uniform1d                      = &glUniform1dNULL;
        uniform1dv                     = &glUniform1dvNULL;
        uniform2d                      = &glUniform2dNULL;
        uniform2dv                     = &glUniform2dvNULL;
        uniform3d                      = &glUniform3dNULL;
        uniform3dv                     = &glUniform3dvNULL;
        uniform4d                      = &glUniform4dNULL;
        uniform4dv                     = &glUniform4dvNULL;
        uniformMatrix2dv               = &glUniformMatrix2dvNULL;
        uniformMatrix2x3dv             = &glUniformMatrix2x3dvNULL;
        uniformMatrix2x4dv             = &glUniformMatrix2x4dvNULL;
        uniformMatrix3dv               = &glUniformMatrix3dvNULL;
        uniformMatrix3x2dv             = &glUniformMatrix3x2dvNULL;
        uniformMatrix3x4dv             = &glUniformMatrix3x4dvNULL;
        uniformMatrix4dv               = &glUniformMatrix4dvNULL;
        uniformMatrix4x2dv             = &glUniformMatrix4x2dvNULL;
        uniformMatrix4x3dv             = &glUniformMatrix4x3dvNULL;
        uniformSubroutinesuiv          = &glUniformSubroutinesuivNULL;
    }

    if (version >= gl::Version(4, 1))
    {
        activeShaderProgram       = &glActiveShaderProgramNULL;
        bindProgramPipeline       = &glBindProgramPipelineNULL;
        clearDepthf               = &glClearDepthfNULL;
        createShaderProgramv      = &glCreateShaderProgramvNULL;
        deleteProgramPipelines    = &glDeleteProgramPipelinesNULL;
        depthRangeArrayv          = &glDepthRangeArrayvNULL;
        depthRangeIndexed         = &glDepthRangeIndexedNULL;
        depthRangef               = &glDepthRangefNULL;
        genProgramPipelines       = &glGenProgramPipelinesNULL;
        getDoublei_v              = &glGetDoublei_vNULL;
        getFloati_v               = &glGetFloati_vNULL;
        getProgramBinary          = &glGetProgramBinaryNULL;
        getProgramPipelineInfoLog = &glGetProgramPipelineInfoLogNULL;
        getProgramPipelineiv      = &glGetProgramPipelineivNULL;
        getShaderPrecisionFormat  = &glGetShaderPrecisionFormatNULL;
        getVertexAttribLdv        = &glGetVertexAttribLdvNULL;
        isProgramPipeline         = &glIsProgramPipelineNULL;
        programBinary             = &glProgramBinaryNULL;
        programParameteri         = &glProgramParameteriNULL;
        programUniform1d          = &glProgramUniform1dNULL;
        programUniform1dv         = &glProgramUniform1dvNULL;
        programUniform1f          = &glProgramUniform1fNULL;
        programUniform1fv         = &glProgramUniform1fvNULL;
        programUniform1i          = &glProgramUniform1iNULL;
        programUniform1iv         = &glProgramUniform1ivNULL;
        programUniform1ui         = &glProgramUniform1uiNULL;
        programUniform1uiv        = &glProgramUniform1uivNULL;
        programUniform2d          = &glProgramUniform2dNULL;
        programUniform2dv         = &glProgramUniform2dvNULL;
        programUniform2f          = &glProgramUniform2fNULL;
        programUniform2fv         = &glProgramUniform2fvNULL;
        programUniform2i          = &glProgramUniform2iNULL;
        programUniform2iv         = &glProgramUniform2ivNULL;
        programUniform2ui         = &glProgramUniform2uiNULL;
        programUniform2uiv        = &glProgramUniform2uivNULL;
        programUniform3d          = &glProgramUniform3dNULL;
        programUniform3dv         = &glProgramUniform3dvNULL;
        programUniform3f          = &glProgramUniform3fNULL;
        programUniform3fv         = &glProgramUniform3fvNULL;
        programUniform3i          = &glProgramUniform3iNULL;
        programUniform3iv         = &glProgramUniform3ivNULL;
        programUniform3ui         = &glProgramUniform3uiNULL;
        programUniform3uiv        = &glProgramUniform3uivNULL;
        programUniform4d          = &glProgramUniform4dNULL;
        programUniform4dv         = &glProgramUniform4dvNULL;
        programUniform4f          = &glProgramUniform4fNULL;
        programUniform4fv         = &glProgramUniform4fvNULL;
        programUniform4i          = &glProgramUniform4iNULL;
        programUniform4iv         = &glProgramUniform4ivNULL;
        programUniform4ui         = &glProgramUniform4uiNULL;
        programUniform4uiv        = &glProgramUniform4uivNULL;
        programUniformMatrix2dv   = &glProgramUniformMatrix2dvNULL;
        programUniformMatrix2fv   = &glProgramUniformMatrix2fvNULL;
        programUniformMatrix2x3dv = &glProgramUniformMatrix2x3dvNULL;
        programUniformMatrix2x3fv = &glProgramUniformMatrix2x3fvNULL;
        programUniformMatrix2x4dv = &glProgramUniformMatrix2x4dvNULL;
        programUniformMatrix2x4fv = &glProgramUniformMatrix2x4fvNULL;
        programUniformMatrix3dv   = &glProgramUniformMatrix3dvNULL;
        programUniformMatrix3fv   = &glProgramUniformMatrix3fvNULL;
        programUniformMatrix3x2dv = &glProgramUniformMatrix3x2dvNULL;
        programUniformMatrix3x2fv = &glProgramUniformMatrix3x2fvNULL;
        programUniformMatrix3x4dv = &glProgramUniformMatrix3x4dvNULL;
        programUniformMatrix3x4fv = &glProgramUniformMatrix3x4fvNULL;
        programUniformMatrix4dv   = &glProgramUniformMatrix4dvNULL;
        programUniformMatrix4fv   = &glProgramUniformMatrix4fvNULL;
        programUniformMatrix4x2dv = &glProgramUniformMatrix4x2dvNULL;
        programUniformMatrix4x2fv = &glProgramUniformMatrix4x2fvNULL;
        programUniformMatrix4x3dv = &glProgramUniformMatrix4x3dvNULL;
        programUniformMatrix4x3fv = &glProgramUniformMatrix4x3fvNULL;
        releaseShaderCompiler     = &glReleaseShaderCompilerNULL;
        scissorArrayv             = &glScissorArrayvNULL;
        scissorIndexed            = &glScissorIndexedNULL;
        scissorIndexedv           = &glScissorIndexedvNULL;
        shaderBinary              = &glShaderBinaryNULL;
        useProgramStages          = &glUseProgramStagesNULL;
        validateProgramPipeline   = &glValidateProgramPipelineNULL;
        vertexAttribL1d           = &glVertexAttribL1dNULL;
        vertexAttribL1dv          = &glVertexAttribL1dvNULL;
        vertexAttribL2d           = &glVertexAttribL2dNULL;
        vertexAttribL2dv          = &glVertexAttribL2dvNULL;
        vertexAttribL3d           = &glVertexAttribL3dNULL;
        vertexAttribL3dv          = &glVertexAttribL3dvNULL;
        vertexAttribL4d           = &glVertexAttribL4dNULL;
        vertexAttribL4dv          = &glVertexAttribL4dvNULL;
        vertexAttribLPointer      = &glVertexAttribLPointerNULL;
        viewportArrayv            = &glViewportArrayvNULL;
        viewportIndexedf          = &glViewportIndexedfNULL;
        viewportIndexedfv         = &glViewportIndexedfvNULL;
    }

    if (version >= gl::Version(4, 2))
    {
        bindImageTexture                  = &glBindImageTextureNULL;
        drawArraysInstancedBaseInstance   = &glDrawArraysInstancedBaseInstanceNULL;
        drawElementsInstancedBaseInstance = &glDrawElementsInstancedBaseInstanceNULL;
        drawElementsInstancedBaseVertexBaseInstance =
            &glDrawElementsInstancedBaseVertexBaseInstanceNULL;
        drawTransformFeedbackInstanced       = &glDrawTransformFeedbackInstancedNULL;
        drawTransformFeedbackStreamInstanced = &glDrawTransformFeedbackStreamInstancedNULL;
        getActiveAtomicCounterBufferiv       = &glGetActiveAtomicCounterBufferivNULL;
        getInternalformativ                  = &glGetInternalformativNULL;
        memoryBarrier                        = &glMemoryBarrierNULL;
        texStorage1D                         = &glTexStorage1DNULL;
        texStorage2D                         = &glTexStorage2DNULL;
        texStorage3D                         = &glTexStorage3DNULL;
    }

    if (version >= gl::Version(4, 3))
    {
        bindVertexBuffer                = &glBindVertexBufferNULL;
        clearBufferData                 = &glClearBufferDataNULL;
        clearBufferSubData              = &glClearBufferSubDataNULL;
        copyImageSubData                = &glCopyImageSubDataNULL;
        debugMessageCallback            = &glDebugMessageCallbackNULL;
        debugMessageControl             = &glDebugMessageControlNULL;
        debugMessageInsert              = &glDebugMessageInsertNULL;
        dispatchCompute                 = &glDispatchComputeNULL;
        dispatchComputeIndirect         = &glDispatchComputeIndirectNULL;
        framebufferParameteri           = &glFramebufferParameteriNULL;
        getDebugMessageLog              = &glGetDebugMessageLogNULL;
        getFramebufferParameteriv       = &glGetFramebufferParameterivNULL;
        getInternalformati64v           = &glGetInternalformati64vNULL;
        getObjectLabel                  = &glGetObjectLabelNULL;
        getObjectPtrLabel               = &glGetObjectPtrLabelNULL;
        getPointerv                     = &glGetPointervNULL;
        getProgramInterfaceiv           = &glGetProgramInterfaceivNULL;
        getProgramResourceIndex         = &glGetProgramResourceIndexNULL;
        getProgramResourceLocation      = &glGetProgramResourceLocationNULL;
        getProgramResourceLocationIndex = &glGetProgramResourceLocationIndexNULL;
        getProgramResourceName          = &glGetProgramResourceNameNULL;
        getProgramResourceiv            = &glGetProgramResourceivNULL;
        invalidateBufferData            = &glInvalidateBufferDataNULL;
        invalidateBufferSubData         = &glInvalidateBufferSubDataNULL;
        invalidateFramebuffer           = &glInvalidateFramebufferNULL;
        invalidateSubFramebuffer        = &glInvalidateSubFramebufferNULL;
        invalidateTexImage              = &glInvalidateTexImageNULL;
        invalidateTexSubImage           = &glInvalidateTexSubImageNULL;
        multiDrawArraysIndirect         = &glMultiDrawArraysIndirectNULL;
        multiDrawElementsIndirect       = &glMultiDrawElementsIndirectNULL;
        objectLabel                     = &glObjectLabelNULL;
        objectPtrLabel                  = &glObjectPtrLabelNULL;
        popDebugGroup                   = &glPopDebugGroupNULL;
        pushDebugGroup                  = &glPushDebugGroupNULL;
        shaderStorageBlockBinding       = &glShaderStorageBlockBindingNULL;
        texBufferRange                  = &glTexBufferRangeNULL;
        texStorage2DMultisample         = &glTexStorage2DMultisampleNULL;
        texStorage3DMultisample         = &glTexStorage3DMultisampleNULL;
        textureView                     = &glTextureViewNULL;
        vertexAttribBinding             = &glVertexAttribBindingNULL;
        vertexAttribFormat              = &glVertexAttribFormatNULL;
        vertexAttribIFormat             = &glVertexAttribIFormatNULL;
        vertexAttribLFormat             = &glVertexAttribLFormatNULL;
        vertexBindingDivisor            = &glVertexBindingDivisorNULL;
    }

    if (version >= gl::Version(4, 4))
    {
        bindBuffersBase   = &glBindBuffersBaseNULL;
        bindBuffersRange  = &glBindBuffersRangeNULL;
        bindImageTextures = &glBindImageTexturesNULL;
        bindSamplers      = &glBindSamplersNULL;
        bindTextures      = &glBindTexturesNULL;
        bindVertexBuffers = &glBindVertexBuffersNULL;
        bufferStorage     = &glBufferStorageNULL;
        clearTexImage     = &glClearTexImageNULL;
        clearTexSubImage  = &glClearTexSubImageNULL;
    }

    if (version >= gl::Version(4, 5))
    {
        bindTextureUnit                          = &glBindTextureUnitNULL;
        blitNamedFramebuffer                     = &glBlitNamedFramebufferNULL;
        checkNamedFramebufferStatus              = &glCheckNamedFramebufferStatusNULL;
        clearNamedBufferData                     = &glClearNamedBufferDataNULL;
        clearNamedBufferSubData                  = &glClearNamedBufferSubDataNULL;
        clearNamedFramebufferfi                  = &glClearNamedFramebufferfiNULL;
        clearNamedFramebufferfv                  = &glClearNamedFramebufferfvNULL;
        clearNamedFramebufferiv                  = &glClearNamedFramebufferivNULL;
        clearNamedFramebufferuiv                 = &glClearNamedFramebufferuivNULL;
        clipControl                              = &glClipControlNULL;
        compressedTextureSubImage1D              = &glCompressedTextureSubImage1DNULL;
        compressedTextureSubImage2D              = &glCompressedTextureSubImage2DNULL;
        compressedTextureSubImage3D              = &glCompressedTextureSubImage3DNULL;
        copyNamedBufferSubData                   = &glCopyNamedBufferSubDataNULL;
        copyTextureSubImage1D                    = &glCopyTextureSubImage1DNULL;
        copyTextureSubImage2D                    = &glCopyTextureSubImage2DNULL;
        copyTextureSubImage3D                    = &glCopyTextureSubImage3DNULL;
        createBuffers                            = &glCreateBuffersNULL;
        createFramebuffers                       = &glCreateFramebuffersNULL;
        createProgramPipelines                   = &glCreateProgramPipelinesNULL;
        createQueries                            = &glCreateQueriesNULL;
        createRenderbuffers                      = &glCreateRenderbuffersNULL;
        createSamplers                           = &glCreateSamplersNULL;
        createTextures                           = &glCreateTexturesNULL;
        createTransformFeedbacks                 = &glCreateTransformFeedbacksNULL;
        createVertexArrays                       = &glCreateVertexArraysNULL;
        disableVertexArrayAttrib                 = &glDisableVertexArrayAttribNULL;
        enableVertexArrayAttrib                  = &glEnableVertexArrayAttribNULL;
        flushMappedNamedBufferRange              = &glFlushMappedNamedBufferRangeNULL;
        generateTextureMipmap                    = &glGenerateTextureMipmapNULL;
        getCompressedTextureImage                = &glGetCompressedTextureImageNULL;
        getCompressedTextureSubImage             = &glGetCompressedTextureSubImageNULL;
        getGraphicsResetStatus                   = &glGetGraphicsResetStatusNULL;
        getNamedBufferParameteri64v              = &glGetNamedBufferParameteri64vNULL;
        getNamedBufferParameteriv                = &glGetNamedBufferParameterivNULL;
        getNamedBufferPointerv                   = &glGetNamedBufferPointervNULL;
        getNamedBufferSubData                    = &glGetNamedBufferSubDataNULL;
        getNamedFramebufferAttachmentParameteriv = &glGetNamedFramebufferAttachmentParameterivNULL;
        getNamedFramebufferParameteriv           = &glGetNamedFramebufferParameterivNULL;
        getNamedRenderbufferParameteriv          = &glGetNamedRenderbufferParameterivNULL;
        getQueryBufferObjecti64v                 = &glGetQueryBufferObjecti64vNULL;
        getQueryBufferObjectiv                   = &glGetQueryBufferObjectivNULL;
        getQueryBufferObjectui64v                = &glGetQueryBufferObjectui64vNULL;
        getQueryBufferObjectuiv                  = &glGetQueryBufferObjectuivNULL;
        getTextureImage                          = &glGetTextureImageNULL;
        getTextureLevelParameterfv               = &glGetTextureLevelParameterfvNULL;
        getTextureLevelParameteriv               = &glGetTextureLevelParameterivNULL;
        getTextureParameterIiv                   = &glGetTextureParameterIivNULL;
        getTextureParameterIuiv                  = &glGetTextureParameterIuivNULL;
        getTextureParameterfv                    = &glGetTextureParameterfvNULL;
        getTextureParameteriv                    = &glGetTextureParameterivNULL;
        getTextureSubImage                       = &glGetTextureSubImageNULL;
        getTransformFeedbacki64_v                = &glGetTransformFeedbacki64_vNULL;
        getTransformFeedbacki_v                  = &glGetTransformFeedbacki_vNULL;
        getTransformFeedbackiv                   = &glGetTransformFeedbackivNULL;
        getVertexArrayIndexed64iv                = &glGetVertexArrayIndexed64ivNULL;
        getVertexArrayIndexediv                  = &glGetVertexArrayIndexedivNULL;
        getVertexArrayiv                         = &glGetVertexArrayivNULL;
        getnCompressedTexImage                   = &glGetnCompressedTexImageNULL;
        getnTexImage                             = &glGetnTexImageNULL;
        getnUniformdv                            = &glGetnUniformdvNULL;
        getnUniformfv                            = &glGetnUniformfvNULL;
        getnUniformiv                            = &glGetnUniformivNULL;
        getnUniformuiv                           = &glGetnUniformuivNULL;
        invalidateNamedFramebufferData           = &glInvalidateNamedFramebufferDataNULL;
        invalidateNamedFramebufferSubData        = &glInvalidateNamedFramebufferSubDataNULL;
        mapNamedBuffer                           = &glMapNamedBufferNULL;
        mapNamedBufferRange                      = &glMapNamedBufferRangeNULL;
        memoryBarrierByRegion                    = &glMemoryBarrierByRegionNULL;
        namedBufferData                          = &glNamedBufferDataNULL;
        namedBufferStorage                       = &glNamedBufferStorageNULL;
        namedBufferSubData                       = &glNamedBufferSubDataNULL;
        namedFramebufferDrawBuffer               = &glNamedFramebufferDrawBufferNULL;
        namedFramebufferDrawBuffers              = &glNamedFramebufferDrawBuffersNULL;
        namedFramebufferParameteri               = &glNamedFramebufferParameteriNULL;
        namedFramebufferReadBuffer               = &glNamedFramebufferReadBufferNULL;
        namedFramebufferRenderbuffer             = &glNamedFramebufferRenderbufferNULL;
        namedFramebufferTexture                  = &glNamedFramebufferTextureNULL;
        namedFramebufferTextureLayer             = &glNamedFramebufferTextureLayerNULL;
        namedRenderbufferStorage                 = &glNamedRenderbufferStorageNULL;
        namedRenderbufferStorageMultisample      = &glNamedRenderbufferStorageMultisampleNULL;
        readnPixels                              = &glReadnPixelsNULL;
        textureBarrier                           = &glTextureBarrierNULL;
        textureBuffer                            = &glTextureBufferNULL;
        textureBufferRange                       = &glTextureBufferRangeNULL;
        textureParameterIiv                      = &glTextureParameterIivNULL;
        textureParameterIuiv                     = &glTextureParameterIuivNULL;
        textureParameterf                        = &glTextureParameterfNULL;
        textureParameterfv                       = &glTextureParameterfvNULL;
        textureParameteri                        = &glTextureParameteriNULL;
        textureParameteriv                       = &glTextureParameterivNULL;
        textureStorage1D                         = &glTextureStorage1DNULL;
        textureStorage2D                         = &glTextureStorage2DNULL;
        textureStorage2DMultisample              = &glTextureStorage2DMultisampleNULL;
        textureStorage3D                         = &glTextureStorage3DNULL;
        textureStorage3DMultisample              = &glTextureStorage3DMultisampleNULL;
        textureSubImage1D                        = &glTextureSubImage1DNULL;
        textureSubImage2D                        = &glTextureSubImage2DNULL;
        textureSubImage3D                        = &glTextureSubImage3DNULL;
        transformFeedbackBufferBase              = &glTransformFeedbackBufferBaseNULL;
        transformFeedbackBufferRange             = &glTransformFeedbackBufferRangeNULL;
        unmapNamedBuffer                         = &glUnmapNamedBufferNULL;
        vertexArrayAttribBinding                 = &glVertexArrayAttribBindingNULL;
        vertexArrayAttribFormat                  = &glVertexArrayAttribFormatNULL;
        vertexArrayAttribIFormat                 = &glVertexArrayAttribIFormatNULL;
        vertexArrayAttribLFormat                 = &glVertexArrayAttribLFormatNULL;
        vertexArrayBindingDivisor                = &glVertexArrayBindingDivisorNULL;
        vertexArrayElementBuffer                 = &glVertexArrayElementBufferNULL;
        vertexArrayVertexBuffer                  = &glVertexArrayVertexBufferNULL;
        vertexArrayVertexBuffers                 = &glVertexArrayVertexBuffersNULL;
    }

    if (extensions.count("GL_ARB_ES2_compatibility") != 0)
    {
        clearDepthf              = &glClearDepthfNULL;
        depthRangef              = &glDepthRangefNULL;
        getShaderPrecisionFormat = &glGetShaderPrecisionFormatNULL;
        releaseShaderCompiler    = &glReleaseShaderCompilerNULL;
        shaderBinary             = &glShaderBinaryNULL;
    }

    if (extensions.count("GL_ARB_ES3_1_compatibility") != 0)
    {
        memoryBarrierByRegion = &glMemoryBarrierByRegionNULL;
    }

    if (extensions.count("GL_ARB_ES3_2_compatibility") != 0)
    {
        primitiveBoundingBox = &glPrimitiveBoundingBoxNULL;
    }

    if (extensions.count("GL_ARB_base_instance") != 0)
    {
        drawArraysInstancedBaseInstance   = &glDrawArraysInstancedBaseInstanceNULL;
        drawElementsInstancedBaseInstance = &glDrawElementsInstancedBaseInstanceNULL;
        drawElementsInstancedBaseVertexBaseInstance =
            &glDrawElementsInstancedBaseVertexBaseInstanceNULL;
    }

    if (extensions.count("GL_ARB_blend_func_extended") != 0)
    {
        bindFragDataLocationIndexed = &glBindFragDataLocationIndexedNULL;
        getFragDataIndex            = &glGetFragDataIndexNULL;
    }

    if (extensions.count("GL_ARB_buffer_storage") != 0)
    {
        bufferStorage = &glBufferStorageNULL;
    }

    if (extensions.count("GL_ARB_clear_buffer_object") != 0)
    {
        clearBufferData    = &glClearBufferDataNULL;
        clearBufferSubData = &glClearBufferSubDataNULL;
    }

    if (extensions.count("GL_ARB_clear_texture") != 0)
    {
        clearTexImage    = &glClearTexImageNULL;
        clearTexSubImage = &glClearTexSubImageNULL;
    }

    if (extensions.count("GL_ARB_clip_control") != 0)
    {
        clipControl = &glClipControlNULL;
    }

    if (extensions.count("GL_ARB_color_buffer_float") != 0)
    {
        clampColor = &glClampColorNULL;
    }

    if (extensions.count("GL_ARB_compute_shader") != 0)
    {
        dispatchCompute         = &glDispatchComputeNULL;
        dispatchComputeIndirect = &glDispatchComputeIndirectNULL;
    }

    if (extensions.count("GL_ARB_copy_buffer") != 0)
    {
        copyBufferSubData = &glCopyBufferSubDataNULL;
    }

    if (extensions.count("GL_ARB_copy_image") != 0)
    {
        copyImageSubData = &glCopyImageSubDataNULL;
    }

    if (extensions.count("GL_ARB_debug_output") != 0)
    {
        debugMessageCallback = &glDebugMessageCallbackNULL;
        debugMessageControl  = &glDebugMessageControlNULL;
        debugMessageInsert   = &glDebugMessageInsertNULL;
        getDebugMessageLog   = &glGetDebugMessageLogNULL;
    }

    if (extensions.count("GL_ARB_direct_state_access") != 0)
    {
        bindTextureUnit                          = &glBindTextureUnitNULL;
        blitNamedFramebuffer                     = &glBlitNamedFramebufferNULL;
        checkNamedFramebufferStatus              = &glCheckNamedFramebufferStatusNULL;
        clearNamedBufferData                     = &glClearNamedBufferDataNULL;
        clearNamedBufferSubData                  = &glClearNamedBufferSubDataNULL;
        clearNamedFramebufferfi                  = &glClearNamedFramebufferfiNULL;
        clearNamedFramebufferfv                  = &glClearNamedFramebufferfvNULL;
        clearNamedFramebufferiv                  = &glClearNamedFramebufferivNULL;
        clearNamedFramebufferuiv                 = &glClearNamedFramebufferuivNULL;
        compressedTextureSubImage1D              = &glCompressedTextureSubImage1DNULL;
        compressedTextureSubImage2D              = &glCompressedTextureSubImage2DNULL;
        compressedTextureSubImage3D              = &glCompressedTextureSubImage3DNULL;
        copyNamedBufferSubData                   = &glCopyNamedBufferSubDataNULL;
        copyTextureSubImage1D                    = &glCopyTextureSubImage1DNULL;
        copyTextureSubImage2D                    = &glCopyTextureSubImage2DNULL;
        copyTextureSubImage3D                    = &glCopyTextureSubImage3DNULL;
        createBuffers                            = &glCreateBuffersNULL;
        createFramebuffers                       = &glCreateFramebuffersNULL;
        createProgramPipelines                   = &glCreateProgramPipelinesNULL;
        createQueries                            = &glCreateQueriesNULL;
        createRenderbuffers                      = &glCreateRenderbuffersNULL;
        createSamplers                           = &glCreateSamplersNULL;
        createTextures                           = &glCreateTexturesNULL;
        createTransformFeedbacks                 = &glCreateTransformFeedbacksNULL;
        createVertexArrays                       = &glCreateVertexArraysNULL;
        disableVertexArrayAttrib                 = &glDisableVertexArrayAttribNULL;
        enableVertexArrayAttrib                  = &glEnableVertexArrayAttribNULL;
        flushMappedNamedBufferRange              = &glFlushMappedNamedBufferRangeNULL;
        generateTextureMipmap                    = &glGenerateTextureMipmapNULL;
        getCompressedTextureImage                = &glGetCompressedTextureImageNULL;
        getNamedBufferParameteri64v              = &glGetNamedBufferParameteri64vNULL;
        getNamedBufferParameteriv                = &glGetNamedBufferParameterivNULL;
        getNamedBufferPointerv                   = &glGetNamedBufferPointervNULL;
        getNamedBufferSubData                    = &glGetNamedBufferSubDataNULL;
        getNamedFramebufferAttachmentParameteriv = &glGetNamedFramebufferAttachmentParameterivNULL;
        getNamedFramebufferParameteriv           = &glGetNamedFramebufferParameterivNULL;
        getNamedRenderbufferParameteriv          = &glGetNamedRenderbufferParameterivNULL;
        getQueryBufferObjecti64v                 = &glGetQueryBufferObjecti64vNULL;
        getQueryBufferObjectiv                   = &glGetQueryBufferObjectivNULL;
        getQueryBufferObjectui64v                = &glGetQueryBufferObjectui64vNULL;
        getQueryBufferObjectuiv                  = &glGetQueryBufferObjectuivNULL;
        getTextureImage                          = &glGetTextureImageNULL;
        getTextureLevelParameterfv               = &glGetTextureLevelParameterfvNULL;
        getTextureLevelParameteriv               = &glGetTextureLevelParameterivNULL;
        getTextureParameterIiv                   = &glGetTextureParameterIivNULL;
        getTextureParameterIuiv                  = &glGetTextureParameterIuivNULL;
        getTextureParameterfv                    = &glGetTextureParameterfvNULL;
        getTextureParameteriv                    = &glGetTextureParameterivNULL;
        getTransformFeedbacki64_v                = &glGetTransformFeedbacki64_vNULL;
        getTransformFeedbacki_v                  = &glGetTransformFeedbacki_vNULL;
        getTransformFeedbackiv                   = &glGetTransformFeedbackivNULL;
        getVertexArrayIndexed64iv                = &glGetVertexArrayIndexed64ivNULL;
        getVertexArrayIndexediv                  = &glGetVertexArrayIndexedivNULL;
        getVertexArrayiv                         = &glGetVertexArrayivNULL;
        invalidateNamedFramebufferData           = &glInvalidateNamedFramebufferDataNULL;
        invalidateNamedFramebufferSubData        = &glInvalidateNamedFramebufferSubDataNULL;
        mapNamedBuffer                           = &glMapNamedBufferNULL;
        mapNamedBufferRange                      = &glMapNamedBufferRangeNULL;
        namedBufferData                          = &glNamedBufferDataNULL;
        namedBufferStorage                       = &glNamedBufferStorageNULL;
        namedBufferSubData                       = &glNamedBufferSubDataNULL;
        namedFramebufferDrawBuffer               = &glNamedFramebufferDrawBufferNULL;
        namedFramebufferDrawBuffers              = &glNamedFramebufferDrawBuffersNULL;
        namedFramebufferParameteri               = &glNamedFramebufferParameteriNULL;
        namedFramebufferReadBuffer               = &glNamedFramebufferReadBufferNULL;
        namedFramebufferRenderbuffer             = &glNamedFramebufferRenderbufferNULL;
        namedFramebufferTexture                  = &glNamedFramebufferTextureNULL;
        namedFramebufferTextureLayer             = &glNamedFramebufferTextureLayerNULL;
        namedRenderbufferStorage                 = &glNamedRenderbufferStorageNULL;
        namedRenderbufferStorageMultisample      = &glNamedRenderbufferStorageMultisampleNULL;
        textureBuffer                            = &glTextureBufferNULL;
        textureBufferRange                       = &glTextureBufferRangeNULL;
        textureParameterIiv                      = &glTextureParameterIivNULL;
        textureParameterIuiv                     = &glTextureParameterIuivNULL;
        textureParameterf                        = &glTextureParameterfNULL;
        textureParameterfv                       = &glTextureParameterfvNULL;
        textureParameteri                        = &glTextureParameteriNULL;
        textureParameteriv                       = &glTextureParameterivNULL;
        textureStorage1D                         = &glTextureStorage1DNULL;
        textureStorage2D                         = &glTextureStorage2DNULL;
        textureStorage2DMultisample              = &glTextureStorage2DMultisampleNULL;
        textureStorage3D                         = &glTextureStorage3DNULL;
        textureStorage3DMultisample              = &glTextureStorage3DMultisampleNULL;
        textureSubImage1D                        = &glTextureSubImage1DNULL;
        textureSubImage2D                        = &glTextureSubImage2DNULL;
        textureSubImage3D                        = &glTextureSubImage3DNULL;
        transformFeedbackBufferBase              = &glTransformFeedbackBufferBaseNULL;
        transformFeedbackBufferRange             = &glTransformFeedbackBufferRangeNULL;
        unmapNamedBuffer                         = &glUnmapNamedBufferNULL;
        vertexArrayAttribBinding                 = &glVertexArrayAttribBindingNULL;
        vertexArrayAttribFormat                  = &glVertexArrayAttribFormatNULL;
        vertexArrayAttribIFormat                 = &glVertexArrayAttribIFormatNULL;
        vertexArrayAttribLFormat                 = &glVertexArrayAttribLFormatNULL;
        vertexArrayBindingDivisor                = &glVertexArrayBindingDivisorNULL;
        vertexArrayElementBuffer                 = &glVertexArrayElementBufferNULL;
        vertexArrayVertexBuffer                  = &glVertexArrayVertexBufferNULL;
        vertexArrayVertexBuffers                 = &glVertexArrayVertexBuffersNULL;
    }

    if (extensions.count("GL_ARB_draw_buffers") != 0)
    {
        drawBuffers = &glDrawBuffersNULL;
    }

    if (extensions.count("GL_ARB_draw_buffers_blend") != 0)
    {
        blendEquationSeparatei = &glBlendEquationSeparateiNULL;
        blendEquationi         = &glBlendEquationiNULL;
        blendFuncSeparatei     = &glBlendFuncSeparateiNULL;
        blendFunci             = &glBlendFunciNULL;
    }

    if (extensions.count("GL_ARB_draw_elements_base_vertex") != 0)
    {
        drawElementsBaseVertex          = &glDrawElementsBaseVertexNULL;
        drawElementsInstancedBaseVertex = &glDrawElementsInstancedBaseVertexNULL;
        drawRangeElementsBaseVertex     = &glDrawRangeElementsBaseVertexNULL;
        multiDrawElementsBaseVertex     = &glMultiDrawElementsBaseVertexNULL;
    }

    if (extensions.count("GL_ARB_draw_indirect") != 0)
    {
        drawArraysIndirect   = &glDrawArraysIndirectNULL;
        drawElementsIndirect = &glDrawElementsIndirectNULL;
    }

    if (extensions.count("GL_ARB_draw_instanced") != 0)
    {
        drawArraysInstanced   = &glDrawArraysInstancedNULL;
        drawElementsInstanced = &glDrawElementsInstancedNULL;
    }

    if (extensions.count("GL_ARB_fragment_program") != 0)
    {
        getProgramiv = &glGetProgramivNULL;
        isProgram    = &glIsProgramNULL;
    }

    if (extensions.count("GL_ARB_framebuffer_no_attachments") != 0)
    {
        framebufferParameteri     = &glFramebufferParameteriNULL;
        getFramebufferParameteriv = &glGetFramebufferParameterivNULL;
    }

    if (extensions.count("GL_ARB_framebuffer_object") != 0)
    {
        bindFramebuffer                     = &glBindFramebufferNULL;
        bindRenderbuffer                    = &glBindRenderbufferNULL;
        blitFramebuffer                     = &glBlitFramebufferNULL;
        checkFramebufferStatus              = &glCheckFramebufferStatusNULL;
        deleteFramebuffers                  = &glDeleteFramebuffersNULL;
        deleteRenderbuffers                 = &glDeleteRenderbuffersNULL;
        framebufferRenderbuffer             = &glFramebufferRenderbufferNULL;
        framebufferTexture1D                = &glFramebufferTexture1DNULL;
        framebufferTexture2D                = &glFramebufferTexture2DNULL;
        framebufferTexture3D                = &glFramebufferTexture3DNULL;
        framebufferTextureLayer             = &glFramebufferTextureLayerNULL;
        genFramebuffers                     = &glGenFramebuffersNULL;
        genRenderbuffers                    = &glGenRenderbuffersNULL;
        generateMipmap                      = &glGenerateMipmapNULL;
        getFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameterivNULL;
        getRenderbufferParameteriv          = &glGetRenderbufferParameterivNULL;
        isFramebuffer                       = &glIsFramebufferNULL;
        isRenderbuffer                      = &glIsRenderbufferNULL;
        renderbufferStorage                 = &glRenderbufferStorageNULL;
        renderbufferStorageMultisample      = &glRenderbufferStorageMultisampleNULL;
    }

    if (extensions.count("GL_ARB_geometry_shader4") != 0)
    {
        framebufferTexture      = &glFramebufferTextureNULL;
        framebufferTextureLayer = &glFramebufferTextureLayerNULL;
        programParameteri       = &glProgramParameteriNULL;
    }

    if (extensions.count("GL_ARB_get_program_binary") != 0)
    {
        getProgramBinary  = &glGetProgramBinaryNULL;
        programBinary     = &glProgramBinaryNULL;
        programParameteri = &glProgramParameteriNULL;
    }

    if (extensions.count("GL_ARB_get_texture_sub_image") != 0)
    {
        getCompressedTextureSubImage = &glGetCompressedTextureSubImageNULL;
        getTextureSubImage           = &glGetTextureSubImageNULL;
    }

    if (extensions.count("GL_ARB_gpu_shader_fp64") != 0)
    {
        getUniformdv       = &glGetUniformdvNULL;
        uniform1d          = &glUniform1dNULL;
        uniform1dv         = &glUniform1dvNULL;
        uniform2d          = &glUniform2dNULL;
        uniform2dv         = &glUniform2dvNULL;
        uniform3d          = &glUniform3dNULL;
        uniform3dv         = &glUniform3dvNULL;
        uniform4d          = &glUniform4dNULL;
        uniform4dv         = &glUniform4dvNULL;
        uniformMatrix2dv   = &glUniformMatrix2dvNULL;
        uniformMatrix2x3dv = &glUniformMatrix2x3dvNULL;
        uniformMatrix2x4dv = &glUniformMatrix2x4dvNULL;
        uniformMatrix3dv   = &glUniformMatrix3dvNULL;
        uniformMatrix3x2dv = &glUniformMatrix3x2dvNULL;
        uniformMatrix3x4dv = &glUniformMatrix3x4dvNULL;
        uniformMatrix4dv   = &glUniformMatrix4dvNULL;
        uniformMatrix4x2dv = &glUniformMatrix4x2dvNULL;
        uniformMatrix4x3dv = &glUniformMatrix4x3dvNULL;
    }

    if (extensions.count("GL_ARB_imaging") != 0)
    {
        blendColor    = &glBlendColorNULL;
        blendEquation = &glBlendEquationNULL;
    }

    if (extensions.count("GL_ARB_instanced_arrays") != 0)
    {
        vertexAttribDivisor = &glVertexAttribDivisorNULL;
    }

    if (extensions.count("GL_ARB_internalformat_query") != 0)
    {
        getInternalformativ = &glGetInternalformativNULL;
    }

    if (extensions.count("GL_ARB_internalformat_query2") != 0)
    {
        getInternalformati64v = &glGetInternalformati64vNULL;
    }

    if (extensions.count("GL_ARB_invalidate_subdata") != 0)
    {
        invalidateBufferData     = &glInvalidateBufferDataNULL;
        invalidateBufferSubData  = &glInvalidateBufferSubDataNULL;
        invalidateFramebuffer    = &glInvalidateFramebufferNULL;
        invalidateSubFramebuffer = &glInvalidateSubFramebufferNULL;
        invalidateTexImage       = &glInvalidateTexImageNULL;
        invalidateTexSubImage    = &glInvalidateTexSubImageNULL;
    }

    if (extensions.count("GL_ARB_map_buffer_range") != 0)
    {
        flushMappedBufferRange = &glFlushMappedBufferRangeNULL;
        mapBufferRange         = &glMapBufferRangeNULL;
    }

    if (extensions.count("GL_ARB_multi_bind") != 0)
    {
        bindBuffersBase   = &glBindBuffersBaseNULL;
        bindBuffersRange  = &glBindBuffersRangeNULL;
        bindImageTextures = &glBindImageTexturesNULL;
        bindSamplers      = &glBindSamplersNULL;
        bindTextures      = &glBindTexturesNULL;
        bindVertexBuffers = &glBindVertexBuffersNULL;
    }

    if (extensions.count("GL_ARB_multi_draw_indirect") != 0)
    {
        multiDrawArraysIndirect   = &glMultiDrawArraysIndirectNULL;
        multiDrawElementsIndirect = &glMultiDrawElementsIndirectNULL;
    }

    if (extensions.count("GL_ARB_multisample") != 0)
    {
        sampleCoverage = &glSampleCoverageNULL;
    }

    if (extensions.count("GL_ARB_multitexture") != 0)
    {
        activeTexture = &glActiveTextureNULL;
    }

    if (extensions.count("GL_ARB_occlusion_query") != 0)
    {
        beginQuery        = &glBeginQueryNULL;
        deleteQueries     = &glDeleteQueriesNULL;
        endQuery          = &glEndQueryNULL;
        genQueries        = &glGenQueriesNULL;
        getQueryObjectiv  = &glGetQueryObjectivNULL;
        getQueryObjectuiv = &glGetQueryObjectuivNULL;
        getQueryiv        = &glGetQueryivNULL;
        isQuery           = &glIsQueryNULL;
    }

    if (extensions.count("GL_ARB_parallel_shader_compile") != 0)
    {
        maxShaderCompilerThreadsARB = &glMaxShaderCompilerThreadsARBNULL;
    }

    if (extensions.count("GL_ARB_point_parameters") != 0)
    {
        pointParameterf  = &glPointParameterfNULL;
        pointParameterfv = &glPointParameterfvNULL;
    }

    if (extensions.count("GL_ARB_program_interface_query") != 0)
    {
        getProgramInterfaceiv           = &glGetProgramInterfaceivNULL;
        getProgramResourceIndex         = &glGetProgramResourceIndexNULL;
        getProgramResourceLocation      = &glGetProgramResourceLocationNULL;
        getProgramResourceLocationIndex = &glGetProgramResourceLocationIndexNULL;
        getProgramResourceName          = &glGetProgramResourceNameNULL;
        getProgramResourceiv            = &glGetProgramResourceivNULL;
    }

    if (extensions.count("GL_ARB_provoking_vertex") != 0)
    {
        provokingVertex = &glProvokingVertexNULL;
    }

    if (extensions.count("GL_ARB_robustness") != 0)
    {
        getGraphicsResetStatus = &glGetGraphicsResetStatusNULL;
        getnCompressedTexImage = &glGetnCompressedTexImageNULL;
        getnTexImage           = &glGetnTexImageNULL;
        getnUniformdv          = &glGetnUniformdvNULL;
        getnUniformfv          = &glGetnUniformfvNULL;
        getnUniformiv          = &glGetnUniformivNULL;
        getnUniformuiv         = &glGetnUniformuivNULL;
        readnPixels            = &glReadnPixelsNULL;
    }

    if (extensions.count("GL_ARB_sample_shading") != 0)
    {
        minSampleShading = &glMinSampleShadingNULL;
    }

    if (extensions.count("GL_ARB_sampler_objects") != 0)
    {
        bindSampler             = &glBindSamplerNULL;
        deleteSamplers          = &glDeleteSamplersNULL;
        genSamplers             = &glGenSamplersNULL;
        getSamplerParameterIiv  = &glGetSamplerParameterIivNULL;
        getSamplerParameterIuiv = &glGetSamplerParameterIuivNULL;
        getSamplerParameterfv   = &glGetSamplerParameterfvNULL;
        getSamplerParameteriv   = &glGetSamplerParameterivNULL;
        isSampler               = &glIsSamplerNULL;
        samplerParameterIiv     = &glSamplerParameterIivNULL;
        samplerParameterIuiv    = &glSamplerParameterIuivNULL;
        samplerParameterf       = &glSamplerParameterfNULL;
        samplerParameterfv      = &glSamplerParameterfvNULL;
        samplerParameteri       = &glSamplerParameteriNULL;
        samplerParameteriv      = &glSamplerParameterivNULL;
    }

    if (extensions.count("GL_ARB_separate_shader_objects") != 0)
    {
        activeShaderProgram       = &glActiveShaderProgramNULL;
        bindProgramPipeline       = &glBindProgramPipelineNULL;
        createShaderProgramv      = &glCreateShaderProgramvNULL;
        deleteProgramPipelines    = &glDeleteProgramPipelinesNULL;
        genProgramPipelines       = &glGenProgramPipelinesNULL;
        getProgramPipelineInfoLog = &glGetProgramPipelineInfoLogNULL;
        getProgramPipelineiv      = &glGetProgramPipelineivNULL;
        isProgramPipeline         = &glIsProgramPipelineNULL;
        programParameteri         = &glProgramParameteriNULL;
        programUniform1d          = &glProgramUniform1dNULL;
        programUniform1dv         = &glProgramUniform1dvNULL;
        programUniform1f          = &glProgramUniform1fNULL;
        programUniform1fv         = &glProgramUniform1fvNULL;
        programUniform1i          = &glProgramUniform1iNULL;
        programUniform1iv         = &glProgramUniform1ivNULL;
        programUniform1ui         = &glProgramUniform1uiNULL;
        programUniform1uiv        = &glProgramUniform1uivNULL;
        programUniform2d          = &glProgramUniform2dNULL;
        programUniform2dv         = &glProgramUniform2dvNULL;
        programUniform2f          = &glProgramUniform2fNULL;
        programUniform2fv         = &glProgramUniform2fvNULL;
        programUniform2i          = &glProgramUniform2iNULL;
        programUniform2iv         = &glProgramUniform2ivNULL;
        programUniform2ui         = &glProgramUniform2uiNULL;
        programUniform2uiv        = &glProgramUniform2uivNULL;
        programUniform3d          = &glProgramUniform3dNULL;
        programUniform3dv         = &glProgramUniform3dvNULL;
        programUniform3f          = &glProgramUniform3fNULL;
        programUniform3fv         = &glProgramUniform3fvNULL;
        programUniform3i          = &glProgramUniform3iNULL;
        programUniform3iv         = &glProgramUniform3ivNULL;
        programUniform3ui         = &glProgramUniform3uiNULL;
        programUniform3uiv        = &glProgramUniform3uivNULL;
        programUniform4d          = &glProgramUniform4dNULL;
        programUniform4dv         = &glProgramUniform4dvNULL;
        programUniform4f          = &glProgramUniform4fNULL;
        programUniform4fv         = &glProgramUniform4fvNULL;
        programUniform4i          = &glProgramUniform4iNULL;
        programUniform4iv         = &glProgramUniform4ivNULL;
        programUniform4ui         = &glProgramUniform4uiNULL;
        programUniform4uiv        = &glProgramUniform4uivNULL;
        programUniformMatrix2dv   = &glProgramUniformMatrix2dvNULL;
        programUniformMatrix2fv   = &glProgramUniformMatrix2fvNULL;
        programUniformMatrix2x3dv = &glProgramUniformMatrix2x3dvNULL;
        programUniformMatrix2x3fv = &glProgramUniformMatrix2x3fvNULL;
        programUniformMatrix2x4dv = &glProgramUniformMatrix2x4dvNULL;
        programUniformMatrix2x4fv = &glProgramUniformMatrix2x4fvNULL;
        programUniformMatrix3dv   = &glProgramUniformMatrix3dvNULL;
        programUniformMatrix3fv   = &glProgramUniformMatrix3fvNULL;
        programUniformMatrix3x2dv = &glProgramUniformMatrix3x2dvNULL;
        programUniformMatrix3x2fv = &glProgramUniformMatrix3x2fvNULL;
        programUniformMatrix3x4dv = &glProgramUniformMatrix3x4dvNULL;
        programUniformMatrix3x4fv = &glProgramUniformMatrix3x4fvNULL;
        programUniformMatrix4dv   = &glProgramUniformMatrix4dvNULL;
        programUniformMatrix4fv   = &glProgramUniformMatrix4fvNULL;
        programUniformMatrix4x2dv = &glProgramUniformMatrix4x2dvNULL;
        programUniformMatrix4x2fv = &glProgramUniformMatrix4x2fvNULL;
        programUniformMatrix4x3dv = &glProgramUniformMatrix4x3dvNULL;
        programUniformMatrix4x3fv = &glProgramUniformMatrix4x3fvNULL;
        useProgramStages          = &glUseProgramStagesNULL;
        validateProgramPipeline   = &glValidateProgramPipelineNULL;
    }

    if (extensions.count("GL_ARB_shader_atomic_counters") != 0)
    {
        getActiveAtomicCounterBufferiv = &glGetActiveAtomicCounterBufferivNULL;
    }

    if (extensions.count("GL_ARB_shader_image_load_store") != 0)
    {
        bindImageTexture = &glBindImageTextureNULL;
        memoryBarrier    = &glMemoryBarrierNULL;
    }

    if (extensions.count("GL_ARB_shader_objects") != 0)
    {
        compileShader      = &glCompileShaderNULL;
        getActiveUniform   = &glGetActiveUniformNULL;
        getShaderSource    = &glGetShaderSourceNULL;
        getUniformLocation = &glGetUniformLocationNULL;
        getUniformfv       = &glGetUniformfvNULL;
        getUniformiv       = &glGetUniformivNULL;
        linkProgram        = &glLinkProgramNULL;
        shaderSource       = &glShaderSourceNULL;
        uniform1f          = &glUniform1fNULL;
        uniform1fv         = &glUniform1fvNULL;
        uniform1i          = &glUniform1iNULL;
        uniform1iv         = &glUniform1ivNULL;
        uniform2f          = &glUniform2fNULL;
        uniform2fv         = &glUniform2fvNULL;
        uniform2i          = &glUniform2iNULL;
        uniform2iv         = &glUniform2ivNULL;
        uniform3f          = &glUniform3fNULL;
        uniform3fv         = &glUniform3fvNULL;
        uniform3i          = &glUniform3iNULL;
        uniform3iv         = &glUniform3ivNULL;
        uniform4f          = &glUniform4fNULL;
        uniform4fv         = &glUniform4fvNULL;
        uniform4i          = &glUniform4iNULL;
        uniform4iv         = &glUniform4ivNULL;
        uniformMatrix2fv   = &glUniformMatrix2fvNULL;
        uniformMatrix3fv   = &glUniformMatrix3fvNULL;
        uniformMatrix4fv   = &glUniformMatrix4fvNULL;
        validateProgram    = &glValidateProgramNULL;
    }

    if (extensions.count("GL_ARB_shader_storage_buffer_object") != 0)
    {
        shaderStorageBlockBinding = &glShaderStorageBlockBindingNULL;
    }

    if (extensions.count("GL_ARB_shader_subroutine") != 0)
    {
        getActiveSubroutineName        = &glGetActiveSubroutineNameNULL;
        getActiveSubroutineUniformName = &glGetActiveSubroutineUniformNameNULL;
        getActiveSubroutineUniformiv   = &glGetActiveSubroutineUniformivNULL;
        getProgramStageiv              = &glGetProgramStageivNULL;
        getSubroutineIndex             = &glGetSubroutineIndexNULL;
        getSubroutineUniformLocation   = &glGetSubroutineUniformLocationNULL;
        getUniformSubroutineuiv        = &glGetUniformSubroutineuivNULL;
        uniformSubroutinesuiv          = &glUniformSubroutinesuivNULL;
    }

    if (extensions.count("GL_ARB_sync") != 0)
    {
        clientWaitSync = &glClientWaitSyncNULL;
        deleteSync     = &glDeleteSyncNULL;
        fenceSync      = &glFenceSyncNULL;
        getInteger64v  = &glGetInteger64vNULL;
        getSynciv      = &glGetSyncivNULL;
        isSync         = &glIsSyncNULL;
        waitSync       = &glWaitSyncNULL;
    }

    if (extensions.count("GL_ARB_tessellation_shader") != 0)
    {
        patchParameterfv = &glPatchParameterfvNULL;
        patchParameteri  = &glPatchParameteriNULL;
    }

    if (extensions.count("GL_ARB_texture_barrier") != 0)
    {
        textureBarrier = &glTextureBarrierNULL;
    }

    if (extensions.count("GL_ARB_texture_buffer_object") != 0)
    {
        texBuffer = &glTexBufferNULL;
    }

    if (extensions.count("GL_ARB_texture_buffer_range") != 0)
    {
        texBufferRange = &glTexBufferRangeNULL;
    }

    if (extensions.count("GL_ARB_texture_compression") != 0)
    {
        compressedTexImage1D    = &glCompressedTexImage1DNULL;
        compressedTexImage2D    = &glCompressedTexImage2DNULL;
        compressedTexImage3D    = &glCompressedTexImage3DNULL;
        compressedTexSubImage1D = &glCompressedTexSubImage1DNULL;
        compressedTexSubImage2D = &glCompressedTexSubImage2DNULL;
        compressedTexSubImage3D = &glCompressedTexSubImage3DNULL;
        getCompressedTexImage   = &glGetCompressedTexImageNULL;
    }

    if (extensions.count("GL_ARB_texture_multisample") != 0)
    {
        getMultisamplefv      = &glGetMultisamplefvNULL;
        sampleMaski           = &glSampleMaskiNULL;
        texImage2DMultisample = &glTexImage2DMultisampleNULL;
        texImage3DMultisample = &glTexImage3DMultisampleNULL;
    }

    if (extensions.count("GL_ARB_texture_storage") != 0)
    {
        texStorage1D = &glTexStorage1DNULL;
        texStorage2D = &glTexStorage2DNULL;
        texStorage3D = &glTexStorage3DNULL;
    }

    if (extensions.count("GL_ARB_texture_storage_multisample") != 0)
    {
        texStorage2DMultisample = &glTexStorage2DMultisampleNULL;
        texStorage3DMultisample = &glTexStorage3DMultisampleNULL;
    }

    if (extensions.count("GL_ARB_texture_view") != 0)
    {
        textureView = &glTextureViewNULL;
    }

    if (extensions.count("GL_ARB_timer_query") != 0)
    {
        getQueryObjecti64v  = &glGetQueryObjecti64vNULL;
        getQueryObjectui64v = &glGetQueryObjectui64vNULL;
        queryCounter        = &glQueryCounterNULL;
    }

    if (extensions.count("GL_ARB_transform_feedback2") != 0)
    {
        bindTransformFeedback    = &glBindTransformFeedbackNULL;
        deleteTransformFeedbacks = &glDeleteTransformFeedbacksNULL;
        drawTransformFeedback    = &glDrawTransformFeedbackNULL;
        genTransformFeedbacks    = &glGenTransformFeedbacksNULL;
        isTransformFeedback      = &glIsTransformFeedbackNULL;
        pauseTransformFeedback   = &glPauseTransformFeedbackNULL;
        resumeTransformFeedback  = &glResumeTransformFeedbackNULL;
    }

    if (extensions.count("GL_ARB_transform_feedback3") != 0)
    {
        beginQueryIndexed           = &glBeginQueryIndexedNULL;
        drawTransformFeedbackStream = &glDrawTransformFeedbackStreamNULL;
        endQueryIndexed             = &glEndQueryIndexedNULL;
        getQueryIndexediv           = &glGetQueryIndexedivNULL;
    }

    if (extensions.count("GL_ARB_transform_feedback_instanced") != 0)
    {
        drawTransformFeedbackInstanced       = &glDrawTransformFeedbackInstancedNULL;
        drawTransformFeedbackStreamInstanced = &glDrawTransformFeedbackStreamInstancedNULL;
    }

    if (extensions.count("GL_ARB_uniform_buffer_object") != 0)
    {
        bindBufferBase            = &glBindBufferBaseNULL;
        bindBufferRange           = &glBindBufferRangeNULL;
        getActiveUniformBlockName = &glGetActiveUniformBlockNameNULL;
        getActiveUniformBlockiv   = &glGetActiveUniformBlockivNULL;
        getActiveUniformName      = &glGetActiveUniformNameNULL;
        getActiveUniformsiv       = &glGetActiveUniformsivNULL;
        getIntegeri_v             = &glGetIntegeri_vNULL;
        getUniformBlockIndex      = &glGetUniformBlockIndexNULL;
        getUniformIndices         = &glGetUniformIndicesNULL;
        uniformBlockBinding       = &glUniformBlockBindingNULL;
    }

    if (extensions.count("GL_ARB_vertex_array_object") != 0)
    {
        bindVertexArray    = &glBindVertexArrayNULL;
        deleteVertexArrays = &glDeleteVertexArraysNULL;
        genVertexArrays    = &glGenVertexArraysNULL;
        isVertexArray      = &glIsVertexArrayNULL;
    }

    if (extensions.count("GL_ARB_vertex_attrib_64bit") != 0)
    {
        getVertexAttribLdv   = &glGetVertexAttribLdvNULL;
        vertexAttribL1d      = &glVertexAttribL1dNULL;
        vertexAttribL1dv     = &glVertexAttribL1dvNULL;
        vertexAttribL2d      = &glVertexAttribL2dNULL;
        vertexAttribL2dv     = &glVertexAttribL2dvNULL;
        vertexAttribL3d      = &glVertexAttribL3dNULL;
        vertexAttribL3dv     = &glVertexAttribL3dvNULL;
        vertexAttribL4d      = &glVertexAttribL4dNULL;
        vertexAttribL4dv     = &glVertexAttribL4dvNULL;
        vertexAttribLPointer = &glVertexAttribLPointerNULL;
    }

    if (extensions.count("GL_ARB_vertex_attrib_binding") != 0)
    {
        bindVertexBuffer     = &glBindVertexBufferNULL;
        vertexAttribBinding  = &glVertexAttribBindingNULL;
        vertexAttribFormat   = &glVertexAttribFormatNULL;
        vertexAttribIFormat  = &glVertexAttribIFormatNULL;
        vertexAttribLFormat  = &glVertexAttribLFormatNULL;
        vertexBindingDivisor = &glVertexBindingDivisorNULL;
    }

    if (extensions.count("GL_ARB_vertex_buffer_object") != 0)
    {
        bindBuffer           = &glBindBufferNULL;
        bufferData           = &glBufferDataNULL;
        bufferSubData        = &glBufferSubDataNULL;
        deleteBuffers        = &glDeleteBuffersNULL;
        genBuffers           = &glGenBuffersNULL;
        getBufferParameteriv = &glGetBufferParameterivNULL;
        getBufferPointerv    = &glGetBufferPointervNULL;
        getBufferSubData     = &glGetBufferSubDataNULL;
        isBuffer             = &glIsBufferNULL;
        mapBuffer            = &glMapBufferNULL;
        unmapBuffer          = &glUnmapBufferNULL;
    }

    if (extensions.count("GL_ARB_vertex_program") != 0)
    {
        disableVertexAttribArray = &glDisableVertexAttribArrayNULL;
        enableVertexAttribArray  = &glEnableVertexAttribArrayNULL;
        getProgramiv             = &glGetProgramivNULL;
        getVertexAttribPointerv  = &glGetVertexAttribPointervNULL;
        getVertexAttribdv        = &glGetVertexAttribdvNULL;
        getVertexAttribfv        = &glGetVertexAttribfvNULL;
        getVertexAttribiv        = &glGetVertexAttribivNULL;
        isProgram                = &glIsProgramNULL;
        vertexAttrib1d           = &glVertexAttrib1dNULL;
        vertexAttrib1dv          = &glVertexAttrib1dvNULL;
        vertexAttrib1f           = &glVertexAttrib1fNULL;
        vertexAttrib1fv          = &glVertexAttrib1fvNULL;
        vertexAttrib1s           = &glVertexAttrib1sNULL;
        vertexAttrib1sv          = &glVertexAttrib1svNULL;
        vertexAttrib2d           = &glVertexAttrib2dNULL;
        vertexAttrib2dv          = &glVertexAttrib2dvNULL;
        vertexAttrib2f           = &glVertexAttrib2fNULL;
        vertexAttrib2fv          = &glVertexAttrib2fvNULL;
        vertexAttrib2s           = &glVertexAttrib2sNULL;
        vertexAttrib2sv          = &glVertexAttrib2svNULL;
        vertexAttrib3d           = &glVertexAttrib3dNULL;
        vertexAttrib3dv          = &glVertexAttrib3dvNULL;
        vertexAttrib3f           = &glVertexAttrib3fNULL;
        vertexAttrib3fv          = &glVertexAttrib3fvNULL;
        vertexAttrib3s           = &glVertexAttrib3sNULL;
        vertexAttrib3sv          = &glVertexAttrib3svNULL;
        vertexAttrib4Nbv         = &glVertexAttrib4NbvNULL;
        vertexAttrib4Niv         = &glVertexAttrib4NivNULL;
        vertexAttrib4Nsv         = &glVertexAttrib4NsvNULL;
        vertexAttrib4Nub         = &glVertexAttrib4NubNULL;
        vertexAttrib4Nubv        = &glVertexAttrib4NubvNULL;
        vertexAttrib4Nuiv        = &glVertexAttrib4NuivNULL;
        vertexAttrib4Nusv        = &glVertexAttrib4NusvNULL;
        vertexAttrib4bv          = &glVertexAttrib4bvNULL;
        vertexAttrib4d           = &glVertexAttrib4dNULL;
        vertexAttrib4dv          = &glVertexAttrib4dvNULL;
        vertexAttrib4f           = &glVertexAttrib4fNULL;
        vertexAttrib4fv          = &glVertexAttrib4fvNULL;
        vertexAttrib4iv          = &glVertexAttrib4ivNULL;
        vertexAttrib4s           = &glVertexAttrib4sNULL;
        vertexAttrib4sv          = &glVertexAttrib4svNULL;
        vertexAttrib4ubv         = &glVertexAttrib4ubvNULL;
        vertexAttrib4uiv         = &glVertexAttrib4uivNULL;
        vertexAttrib4usv         = &glVertexAttrib4usvNULL;
        vertexAttribPointer      = &glVertexAttribPointerNULL;
    }

    if (extensions.count("GL_ARB_vertex_shader") != 0)
    {
        bindAttribLocation       = &glBindAttribLocationNULL;
        disableVertexAttribArray = &glDisableVertexAttribArrayNULL;
        enableVertexAttribArray  = &glEnableVertexAttribArrayNULL;
        getActiveAttrib          = &glGetActiveAttribNULL;
        getAttribLocation        = &glGetAttribLocationNULL;
        getVertexAttribPointerv  = &glGetVertexAttribPointervNULL;
        getVertexAttribdv        = &glGetVertexAttribdvNULL;
        getVertexAttribfv        = &glGetVertexAttribfvNULL;
        getVertexAttribiv        = &glGetVertexAttribivNULL;
        vertexAttrib1d           = &glVertexAttrib1dNULL;
        vertexAttrib1dv          = &glVertexAttrib1dvNULL;
        vertexAttrib1f           = &glVertexAttrib1fNULL;
        vertexAttrib1fv          = &glVertexAttrib1fvNULL;
        vertexAttrib1s           = &glVertexAttrib1sNULL;
        vertexAttrib1sv          = &glVertexAttrib1svNULL;
        vertexAttrib2d           = &glVertexAttrib2dNULL;
        vertexAttrib2dv          = &glVertexAttrib2dvNULL;
        vertexAttrib2f           = &glVertexAttrib2fNULL;
        vertexAttrib2fv          = &glVertexAttrib2fvNULL;
        vertexAttrib2s           = &glVertexAttrib2sNULL;
        vertexAttrib2sv          = &glVertexAttrib2svNULL;
        vertexAttrib3d           = &glVertexAttrib3dNULL;
        vertexAttrib3dv          = &glVertexAttrib3dvNULL;
        vertexAttrib3f           = &glVertexAttrib3fNULL;
        vertexAttrib3fv          = &glVertexAttrib3fvNULL;
        vertexAttrib3s           = &glVertexAttrib3sNULL;
        vertexAttrib3sv          = &glVertexAttrib3svNULL;
        vertexAttrib4Nbv         = &glVertexAttrib4NbvNULL;
        vertexAttrib4Niv         = &glVertexAttrib4NivNULL;
        vertexAttrib4Nsv         = &glVertexAttrib4NsvNULL;
        vertexAttrib4Nub         = &glVertexAttrib4NubNULL;
        vertexAttrib4Nubv        = &glVertexAttrib4NubvNULL;
        vertexAttrib4Nuiv        = &glVertexAttrib4NuivNULL;
        vertexAttrib4Nusv        = &glVertexAttrib4NusvNULL;
        vertexAttrib4bv          = &glVertexAttrib4bvNULL;
        vertexAttrib4d           = &glVertexAttrib4dNULL;
        vertexAttrib4dv          = &glVertexAttrib4dvNULL;
        vertexAttrib4f           = &glVertexAttrib4fNULL;
        vertexAttrib4fv          = &glVertexAttrib4fvNULL;
        vertexAttrib4iv          = &glVertexAttrib4ivNULL;
        vertexAttrib4s           = &glVertexAttrib4sNULL;
        vertexAttrib4sv          = &glVertexAttrib4svNULL;
        vertexAttrib4ubv         = &glVertexAttrib4ubvNULL;
        vertexAttrib4uiv         = &glVertexAttrib4uivNULL;
        vertexAttrib4usv         = &glVertexAttrib4usvNULL;
        vertexAttribPointer      = &glVertexAttribPointerNULL;
    }

    if (extensions.count("GL_ARB_vertex_type_2_10_10_10_rev") != 0)
    {
        vertexAttribP1ui  = &glVertexAttribP1uiNULL;
        vertexAttribP1uiv = &glVertexAttribP1uivNULL;
        vertexAttribP2ui  = &glVertexAttribP2uiNULL;
        vertexAttribP2uiv = &glVertexAttribP2uivNULL;
        vertexAttribP3ui  = &glVertexAttribP3uiNULL;
        vertexAttribP3uiv = &glVertexAttribP3uivNULL;
        vertexAttribP4ui  = &glVertexAttribP4uiNULL;
        vertexAttribP4uiv = &glVertexAttribP4uivNULL;
    }

    if (extensions.count("GL_ARB_viewport_array") != 0)
    {
        depthRangeArrayv  = &glDepthRangeArrayvNULL;
        depthRangeIndexed = &glDepthRangeIndexedNULL;
        getDoublei_v      = &glGetDoublei_vNULL;
        getFloati_v       = &glGetFloati_vNULL;
        scissorArrayv     = &glScissorArrayvNULL;
        scissorIndexed    = &glScissorIndexedNULL;
        scissorIndexedv   = &glScissorIndexedvNULL;
        viewportArrayv    = &glViewportArrayvNULL;
        viewportIndexedf  = &glViewportIndexedfNULL;
        viewportIndexedfv = &glViewportIndexedfvNULL;
    }

    if (extensions.count("GL_EXT_blend_color") != 0)
    {
        blendColor = &glBlendColorNULL;
    }

    if (extensions.count("GL_EXT_blend_equation_separate") != 0)
    {
        blendEquationSeparate = &glBlendEquationSeparateNULL;
    }

    if (extensions.count("GL_EXT_blend_func_separate") != 0)
    {
        blendFuncSeparate = &glBlendFuncSeparateNULL;
    }

    if (extensions.count("GL_EXT_copy_texture") != 0)
    {
        copyTexImage1D    = &glCopyTexImage1DNULL;
        copyTexImage2D    = &glCopyTexImage2DNULL;
        copyTexSubImage1D = &glCopyTexSubImage1DNULL;
        copyTexSubImage2D = &glCopyTexSubImage2DNULL;
        copyTexSubImage3D = &glCopyTexSubImage3DNULL;
    }

    if (extensions.count("GL_EXT_direct_state_access") != 0)
    {
        checkNamedFramebufferStatus              = &glCheckNamedFramebufferStatusNULL;
        clearNamedBufferData                     = &glClearNamedBufferDataNULL;
        clearNamedBufferSubData                  = &glClearNamedBufferSubDataNULL;
        compressedTextureSubImage1D              = &glCompressedTextureSubImage1DNULL;
        compressedTextureSubImage2D              = &glCompressedTextureSubImage2DNULL;
        compressedTextureSubImage3D              = &glCompressedTextureSubImage3DNULL;
        copyTextureSubImage1D                    = &glCopyTextureSubImage1DNULL;
        copyTextureSubImage2D                    = &glCopyTextureSubImage2DNULL;
        copyTextureSubImage3D                    = &glCopyTextureSubImage3DNULL;
        disableVertexArrayAttrib                 = &glDisableVertexArrayAttribNULL;
        enableVertexArrayAttrib                  = &glEnableVertexArrayAttribNULL;
        flushMappedNamedBufferRange              = &glFlushMappedNamedBufferRangeNULL;
        generateTextureMipmap                    = &glGenerateTextureMipmapNULL;
        getCompressedTextureImage                = &glGetCompressedTextureImageNULL;
        getDoublei_v                             = &glGetDoublei_vNULL;
        getFloati_v                              = &glGetFloati_vNULL;
        getFramebufferParameteriv                = &glGetFramebufferParameterivNULL;
        getNamedBufferParameteriv                = &glGetNamedBufferParameterivNULL;
        getNamedBufferPointerv                   = &glGetNamedBufferPointervNULL;
        getNamedBufferSubData                    = &glGetNamedBufferSubDataNULL;
        getNamedFramebufferAttachmentParameteriv = &glGetNamedFramebufferAttachmentParameterivNULL;
        getNamedFramebufferParameteriv           = &glGetNamedFramebufferParameterivNULL;
        getNamedRenderbufferParameteriv          = &glGetNamedRenderbufferParameterivNULL;
        getTextureImage                          = &glGetTextureImageNULL;
        getTextureLevelParameterfv               = &glGetTextureLevelParameterfvNULL;
        getTextureLevelParameteriv               = &glGetTextureLevelParameterivNULL;
        getTextureParameterIiv                   = &glGetTextureParameterIivNULL;
        getTextureParameterIuiv                  = &glGetTextureParameterIuivNULL;
        getTextureParameterfv                    = &glGetTextureParameterfvNULL;
        getTextureParameteriv                    = &glGetTextureParameterivNULL;
        mapNamedBuffer                           = &glMapNamedBufferNULL;
        mapNamedBufferRange                      = &glMapNamedBufferRangeNULL;
        namedBufferData                          = &glNamedBufferDataNULL;
        namedBufferStorage                       = &glNamedBufferStorageNULL;
        namedBufferSubData                       = &glNamedBufferSubDataNULL;
        namedFramebufferParameteri               = &glNamedFramebufferParameteriNULL;
        namedFramebufferRenderbuffer             = &glNamedFramebufferRenderbufferNULL;
        namedFramebufferTexture                  = &glNamedFramebufferTextureNULL;
        namedFramebufferTextureLayer             = &glNamedFramebufferTextureLayerNULL;
        namedRenderbufferStorage                 = &glNamedRenderbufferStorageNULL;
        namedRenderbufferStorageMultisample      = &glNamedRenderbufferStorageMultisampleNULL;
        programUniform1d                         = &glProgramUniform1dNULL;
        programUniform1dv                        = &glProgramUniform1dvNULL;
        programUniform2d                         = &glProgramUniform2dNULL;
        programUniform2dv                        = &glProgramUniform2dvNULL;
        programUniform3d                         = &glProgramUniform3dNULL;
        programUniform3dv                        = &glProgramUniform3dvNULL;
        programUniform4d                         = &glProgramUniform4dNULL;
        programUniform4dv                        = &glProgramUniform4dvNULL;
        programUniformMatrix2dv                  = &glProgramUniformMatrix2dvNULL;
        programUniformMatrix2x3dv                = &glProgramUniformMatrix2x3dvNULL;
        programUniformMatrix2x4dv                = &glProgramUniformMatrix2x4dvNULL;
        programUniformMatrix3dv                  = &glProgramUniformMatrix3dvNULL;
        programUniformMatrix3x2dv                = &glProgramUniformMatrix3x2dvNULL;
        programUniformMatrix3x4dv                = &glProgramUniformMatrix3x4dvNULL;
        programUniformMatrix4dv                  = &glProgramUniformMatrix4dvNULL;
        programUniformMatrix4x2dv                = &glProgramUniformMatrix4x2dvNULL;
        programUniformMatrix4x3dv                = &glProgramUniformMatrix4x3dvNULL;
        textureBuffer                            = &glTextureBufferNULL;
        textureBufferRange                       = &glTextureBufferRangeNULL;
        textureParameterIiv                      = &glTextureParameterIivNULL;
        textureParameterIuiv                     = &glTextureParameterIuivNULL;
        textureParameterf                        = &glTextureParameterfNULL;
        textureParameterfv                       = &glTextureParameterfvNULL;
        textureParameteri                        = &glTextureParameteriNULL;
        textureParameteriv                       = &glTextureParameterivNULL;
        textureStorage1D                         = &glTextureStorage1DNULL;
        textureStorage2D                         = &glTextureStorage2DNULL;
        textureStorage2DMultisample              = &glTextureStorage2DMultisampleNULL;
        textureStorage3D                         = &glTextureStorage3DNULL;
        textureStorage3DMultisample              = &glTextureStorage3DMultisampleNULL;
        textureSubImage1D                        = &glTextureSubImage1DNULL;
        textureSubImage2D                        = &glTextureSubImage2DNULL;
        textureSubImage3D                        = &glTextureSubImage3DNULL;
        unmapNamedBuffer                         = &glUnmapNamedBufferNULL;
    }

    if (extensions.count("GL_EXT_draw_range_elements") != 0)
    {
        drawRangeElements = &glDrawRangeElementsNULL;
    }

    if (extensions.count("GL_EXT_framebuffer_blit") != 0)
    {
        blitFramebuffer = &glBlitFramebufferNULL;
    }

    if (extensions.count("GL_EXT_framebuffer_multisample") != 0)
    {
        renderbufferStorageMultisample = &glRenderbufferStorageMultisampleNULL;
    }

    if (extensions.count("GL_EXT_framebuffer_object") != 0)
    {
        bindFramebuffer                     = &glBindFramebufferNULL;
        bindRenderbuffer                    = &glBindRenderbufferNULL;
        checkFramebufferStatus              = &glCheckFramebufferStatusNULL;
        deleteFramebuffers                  = &glDeleteFramebuffersNULL;
        deleteRenderbuffers                 = &glDeleteRenderbuffersNULL;
        framebufferRenderbuffer             = &glFramebufferRenderbufferNULL;
        framebufferTexture1D                = &glFramebufferTexture1DNULL;
        framebufferTexture2D                = &glFramebufferTexture2DNULL;
        framebufferTexture3D                = &glFramebufferTexture3DNULL;
        genFramebuffers                     = &glGenFramebuffersNULL;
        genRenderbuffers                    = &glGenRenderbuffersNULL;
        generateMipmap                      = &glGenerateMipmapNULL;
        getFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameterivNULL;
        getRenderbufferParameteriv          = &glGetRenderbufferParameterivNULL;
        isFramebuffer                       = &glIsFramebufferNULL;
        isRenderbuffer                      = &glIsRenderbufferNULL;
        renderbufferStorage                 = &glRenderbufferStorageNULL;
    }

    if (extensions.count("GL_EXT_gpu_shader4") != 0)
    {
        bindFragDataLocation = &glBindFragDataLocationNULL;
        getFragDataLocation  = &glGetFragDataLocationNULL;
        getUniformuiv        = &glGetUniformuivNULL;
        uniform1ui           = &glUniform1uiNULL;
        uniform1uiv          = &glUniform1uivNULL;
        uniform2ui           = &glUniform2uiNULL;
        uniform2uiv          = &glUniform2uivNULL;
        uniform3ui           = &glUniform3uiNULL;
        uniform3uiv          = &glUniform3uivNULL;
        uniform4ui           = &glUniform4uiNULL;
        uniform4uiv          = &glUniform4uivNULL;
    }

    if (extensions.count("GL_EXT_point_parameters") != 0)
    {
        pointParameterf  = &glPointParameterfNULL;
        pointParameterfv = &glPointParameterfvNULL;
    }

    if (extensions.count("GL_EXT_polygon_offset") != 0)
    {
        polygonOffset = &glPolygonOffsetNULL;
    }

    if (extensions.count("GL_EXT_provoking_vertex") != 0)
    {
        provokingVertex = &glProvokingVertexNULL;
    }

    if (extensions.count("GL_EXT_shader_image_load_store") != 0)
    {
        bindImageTexture = &glBindImageTextureNULL;
        memoryBarrier    = &glMemoryBarrierNULL;
    }

    if (extensions.count("GL_EXT_subtexture") != 0)
    {
        texSubImage1D = &glTexSubImage1DNULL;
        texSubImage2D = &glTexSubImage2DNULL;
    }

    if (extensions.count("GL_EXT_texture3D") != 0)
    {
        texImage3D    = &glTexImage3DNULL;
        texSubImage3D = &glTexSubImage3DNULL;
    }

    if (extensions.count("GL_EXT_texture_array") != 0)
    {
        framebufferTextureLayer = &glFramebufferTextureLayerNULL;
    }

    if (extensions.count("GL_EXT_texture_buffer_object") != 0)
    {
        texBuffer = &glTexBufferNULL;
    }

    if (extensions.count("GL_EXT_texture_integer") != 0)
    {
        getTexParameterIiv  = &glGetTexParameterIivNULL;
        getTexParameterIuiv = &glGetTexParameterIuivNULL;
        texParameterIiv     = &glTexParameterIivNULL;
        texParameterIuiv    = &glTexParameterIuivNULL;
    }

    if (extensions.count("GL_EXT_texture_object") != 0)
    {
        bindTexture    = &glBindTextureNULL;
        deleteTextures = &glDeleteTexturesNULL;
        genTextures    = &glGenTexturesNULL;
        isTexture      = &glIsTextureNULL;
    }

    if (extensions.count("GL_EXT_timer_query") != 0)
    {
        getQueryObjecti64v  = &glGetQueryObjecti64vNULL;
        getQueryObjectui64v = &glGetQueryObjectui64vNULL;
    }

    if (extensions.count("GL_EXT_transform_feedback") != 0)
    {
        beginTransformFeedback      = &glBeginTransformFeedbackNULL;
        bindBufferBase              = &glBindBufferBaseNULL;
        bindBufferRange             = &glBindBufferRangeNULL;
        endTransformFeedback        = &glEndTransformFeedbackNULL;
        getTransformFeedbackVarying = &glGetTransformFeedbackVaryingNULL;
        transformFeedbackVaryings   = &glTransformFeedbackVaryingsNULL;
    }

    if (extensions.count("GL_EXT_vertex_array") != 0)
    {
        drawArrays  = &glDrawArraysNULL;
        getPointerv = &glGetPointervNULL;
    }

    if (extensions.count("GL_EXT_vertex_attrib_64bit") != 0)
    {
        getVertexAttribLdv   = &glGetVertexAttribLdvNULL;
        vertexAttribL1d      = &glVertexAttribL1dNULL;
        vertexAttribL1dv     = &glVertexAttribL1dvNULL;
        vertexAttribL2d      = &glVertexAttribL2dNULL;
        vertexAttribL2dv     = &glVertexAttribL2dvNULL;
        vertexAttribL3d      = &glVertexAttribL3dNULL;
        vertexAttribL3dv     = &glVertexAttribL3dvNULL;
        vertexAttribL4d      = &glVertexAttribL4dNULL;
        vertexAttribL4dv     = &glVertexAttribL4dvNULL;
        vertexAttribLPointer = &glVertexAttribLPointerNULL;
    }

    if (extensions.count("GL_KHR_debug") != 0)
    {
        debugMessageCallback = &glDebugMessageCallbackNULL;
        debugMessageControl  = &glDebugMessageControlNULL;
        debugMessageInsert   = &glDebugMessageInsertNULL;
        getDebugMessageLog   = &glGetDebugMessageLogNULL;
        getObjectLabel       = &glGetObjectLabelNULL;
        getObjectPtrLabel    = &glGetObjectPtrLabelNULL;
        getPointerv          = &glGetPointervNULL;
        objectLabel          = &glObjectLabelNULL;
        objectPtrLabel       = &glObjectPtrLabelNULL;
        popDebugGroup        = &glPopDebugGroupNULL;
        pushDebugGroup       = &glPushDebugGroupNULL;
    }

    if (extensions.count("GL_KHR_robustness") != 0)
    {
        getGraphicsResetStatus = &glGetGraphicsResetStatusNULL;
        getnUniformfv          = &glGetnUniformfvNULL;
        getnUniformiv          = &glGetnUniformivNULL;
        getnUniformuiv         = &glGetnUniformuivNULL;
        readnPixels            = &glReadnPixelsNULL;
    }

    if (extensions.count("GL_NV_geometry_program4") != 0)
    {
        framebufferTexture      = &glFramebufferTextureNULL;
        framebufferTextureLayer = &glFramebufferTextureLayerNULL;
    }

    if (extensions.count("GL_NV_vertex_program4") != 0)
    {
        getVertexAttribIiv   = &glGetVertexAttribIivNULL;
        getVertexAttribIuiv  = &glGetVertexAttribIuivNULL;
        vertexAttribI1i      = &glVertexAttribI1iNULL;
        vertexAttribI1iv     = &glVertexAttribI1ivNULL;
        vertexAttribI1ui     = &glVertexAttribI1uiNULL;
        vertexAttribI1uiv    = &glVertexAttribI1uivNULL;
        vertexAttribI2i      = &glVertexAttribI2iNULL;
        vertexAttribI2iv     = &glVertexAttribI2ivNULL;
        vertexAttribI2ui     = &glVertexAttribI2uiNULL;
        vertexAttribI2uiv    = &glVertexAttribI2uivNULL;
        vertexAttribI3i      = &glVertexAttribI3iNULL;
        vertexAttribI3iv     = &glVertexAttribI3ivNULL;
        vertexAttribI3ui     = &glVertexAttribI3uiNULL;
        vertexAttribI3uiv    = &glVertexAttribI3uivNULL;
        vertexAttribI4bv     = &glVertexAttribI4bvNULL;
        vertexAttribI4i      = &glVertexAttribI4iNULL;
        vertexAttribI4iv     = &glVertexAttribI4ivNULL;
        vertexAttribI4sv     = &glVertexAttribI4svNULL;
        vertexAttribI4ubv    = &glVertexAttribI4ubvNULL;
        vertexAttribI4ui     = &glVertexAttribI4uiNULL;
        vertexAttribI4uiv    = &glVertexAttribI4uivNULL;
        vertexAttribI4usv    = &glVertexAttribI4usvNULL;
        vertexAttribIPointer = &glVertexAttribIPointerNULL;
    }

    if (extensions.count("GL_OES_single_precision") != 0)
    {
        clearDepthf = &glClearDepthfNULL;
        depthRangef = &glDepthRangefNULL;
    }
}

void DispatchTableGL::initProcsGLESNULL(const gl::Version &version,
                                        const std::set<std::string> &extensions)
{
    if (version >= gl::Version(2, 0))
    {
        activeTexture                       = &glActiveTextureNULL;
        attachShader                        = &glAttachShaderNULL;
        bindAttribLocation                  = &glBindAttribLocationNULL;
        bindBuffer                          = &glBindBufferNULL;
        bindFramebuffer                     = &glBindFramebufferNULL;
        bindRenderbuffer                    = &glBindRenderbufferNULL;
        bindTexture                         = &glBindTextureNULL;
        blendColor                          = &glBlendColorNULL;
        blendEquation                       = &glBlendEquationNULL;
        blendEquationSeparate               = &glBlendEquationSeparateNULL;
        blendFunc                           = &glBlendFuncNULL;
        blendFuncSeparate                   = &glBlendFuncSeparateNULL;
        bufferData                          = &glBufferDataNULL;
        bufferSubData                       = &glBufferSubDataNULL;
        checkFramebufferStatus              = &glCheckFramebufferStatusNULL;
        clear                               = &glClearNULL;
        clearColor                          = &glClearColorNULL;
        clearDepthf                         = &glClearDepthfNULL;
        clearStencil                        = &glClearStencilNULL;
        colorMask                           = &glColorMaskNULL;
        compileShader                       = &glCompileShaderNULL;
        compressedTexImage2D                = &glCompressedTexImage2DNULL;
        compressedTexSubImage2D             = &glCompressedTexSubImage2DNULL;
        copyTexImage2D                      = &glCopyTexImage2DNULL;
        copyTexSubImage2D                   = &glCopyTexSubImage2DNULL;
        createProgram                       = &glCreateProgramNULL;
        createShader                        = &glCreateShaderNULL;
        cullFace                            = &glCullFaceNULL;
        deleteBuffers                       = &glDeleteBuffersNULL;
        deleteFramebuffers                  = &glDeleteFramebuffersNULL;
        deleteProgram                       = &glDeleteProgramNULL;
        deleteRenderbuffers                 = &glDeleteRenderbuffersNULL;
        deleteShader                        = &glDeleteShaderNULL;
        deleteTextures                      = &glDeleteTexturesNULL;
        depthFunc                           = &glDepthFuncNULL;
        depthMask                           = &glDepthMaskNULL;
        depthRangef                         = &glDepthRangefNULL;
        detachShader                        = &glDetachShaderNULL;
        disable                             = &glDisableNULL;
        disableVertexAttribArray            = &glDisableVertexAttribArrayNULL;
        drawArrays                          = &glDrawArraysNULL;
        drawElements                        = &glDrawElementsNULL;
        enable                              = &glEnableNULL;
        enableVertexAttribArray             = &glEnableVertexAttribArrayNULL;
        finish                              = &glFinishNULL;
        flush                               = &glFlushNULL;
        framebufferRenderbuffer             = &glFramebufferRenderbufferNULL;
        framebufferTexture2D                = &glFramebufferTexture2DNULL;
        frontFace                           = &glFrontFaceNULL;
        genBuffers                          = &glGenBuffersNULL;
        genFramebuffers                     = &glGenFramebuffersNULL;
        genRenderbuffers                    = &glGenRenderbuffersNULL;
        genTextures                         = &glGenTexturesNULL;
        generateMipmap                      = &glGenerateMipmapNULL;
        getActiveAttrib                     = &glGetActiveAttribNULL;
        getActiveUniform                    = &glGetActiveUniformNULL;
        getAttachedShaders                  = &glGetAttachedShadersNULL;
        getAttribLocation                   = &glGetAttribLocationNULL;
        getBooleanv                         = &glGetBooleanvNULL;
        getBufferParameteriv                = &glGetBufferParameterivNULL;
        getError                            = &glGetErrorNULL;
        getFloatv                           = &glGetFloatvNULL;
        getFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameterivNULL;
        getIntegerv                         = &glGetIntegervNULL;
        getProgramInfoLog                   = &glGetProgramInfoLogNULL;
        getProgramiv                        = &glGetProgramivNULL;
        getRenderbufferParameteriv          = &glGetRenderbufferParameterivNULL;
        getShaderInfoLog                    = &glGetShaderInfoLogNULL;
        getShaderPrecisionFormat            = &glGetShaderPrecisionFormatNULL;
        getShaderSource                     = &glGetShaderSourceNULL;
        getShaderiv                         = &glGetShaderivNULL;
        getString                           = &glGetStringNULL;
        getTexParameterfv                   = &glGetTexParameterfvNULL;
        getTexParameteriv                   = &glGetTexParameterivNULL;
        getUniformLocation                  = &glGetUniformLocationNULL;
        getUniformfv                        = &glGetUniformfvNULL;
        getUniformiv                        = &glGetUniformivNULL;
        getVertexAttribPointerv             = &glGetVertexAttribPointervNULL;
        getVertexAttribfv                   = &glGetVertexAttribfvNULL;
        getVertexAttribiv                   = &glGetVertexAttribivNULL;
        hint                                = &glHintNULL;
        isBuffer                            = &glIsBufferNULL;
        isEnabled                           = &glIsEnabledNULL;
        isFramebuffer                       = &glIsFramebufferNULL;
        isProgram                           = &glIsProgramNULL;
        isRenderbuffer                      = &glIsRenderbufferNULL;
        isShader                            = &glIsShaderNULL;
        isTexture                           = &glIsTextureNULL;
        lineWidth                           = &glLineWidthNULL;
        linkProgram                         = &glLinkProgramNULL;
        pixelStorei                         = &glPixelStoreiNULL;
        polygonOffset                       = &glPolygonOffsetNULL;
        readPixels                          = &glReadPixelsNULL;
        releaseShaderCompiler               = &glReleaseShaderCompilerNULL;
        renderbufferStorage                 = &glRenderbufferStorageNULL;
        sampleCoverage                      = &glSampleCoverageNULL;
        scissor                             = &glScissorNULL;
        shaderBinary                        = &glShaderBinaryNULL;
        shaderSource                        = &glShaderSourceNULL;
        stencilFunc                         = &glStencilFuncNULL;
        stencilFuncSeparate                 = &glStencilFuncSeparateNULL;
        stencilMask                         = &glStencilMaskNULL;
        stencilMaskSeparate                 = &glStencilMaskSeparateNULL;
        stencilOp                           = &glStencilOpNULL;
        stencilOpSeparate                   = &glStencilOpSeparateNULL;
        texImage2D                          = &glTexImage2DNULL;
        texParameterf                       = &glTexParameterfNULL;
        texParameterfv                      = &glTexParameterfvNULL;
        texParameteri                       = &glTexParameteriNULL;
        texParameteriv                      = &glTexParameterivNULL;
        texSubImage2D                       = &glTexSubImage2DNULL;
        uniform1f                           = &glUniform1fNULL;
        uniform1fv                          = &glUniform1fvNULL;
        uniform1i                           = &glUniform1iNULL;
        uniform1iv                          = &glUniform1ivNULL;
        uniform2f                           = &glUniform2fNULL;
        uniform2fv                          = &glUniform2fvNULL;
        uniform2i                           = &glUniform2iNULL;
        uniform2iv                          = &glUniform2ivNULL;
        uniform3f                           = &glUniform3fNULL;
        uniform3fv                          = &glUniform3fvNULL;
        uniform3i                           = &glUniform3iNULL;
        uniform3iv                          = &glUniform3ivNULL;
        uniform4f                           = &glUniform4fNULL;
        uniform4fv                          = &glUniform4fvNULL;
        uniform4i                           = &glUniform4iNULL;
        uniform4iv                          = &glUniform4ivNULL;
        uniformMatrix2fv                    = &glUniformMatrix2fvNULL;
        uniformMatrix3fv                    = &glUniformMatrix3fvNULL;
        uniformMatrix4fv                    = &glUniformMatrix4fvNULL;
        useProgram                          = &glUseProgramNULL;
        validateProgram                     = &glValidateProgramNULL;
        vertexAttrib1f                      = &glVertexAttrib1fNULL;
        vertexAttrib1fv                     = &glVertexAttrib1fvNULL;
        vertexAttrib2f                      = &glVertexAttrib2fNULL;
        vertexAttrib2fv                     = &glVertexAttrib2fvNULL;
        vertexAttrib3f                      = &glVertexAttrib3fNULL;
        vertexAttrib3fv                     = &glVertexAttrib3fvNULL;
        vertexAttrib4f                      = &glVertexAttrib4fNULL;
        vertexAttrib4fv                     = &glVertexAttrib4fvNULL;
        vertexAttribPointer                 = &glVertexAttribPointerNULL;
        viewport                            = &glViewportNULL;
    }

    if (version >= gl::Version(3, 0))
    {
        beginQuery                     = &glBeginQueryNULL;
        beginTransformFeedback         = &glBeginTransformFeedbackNULL;
        bindBufferBase                 = &glBindBufferBaseNULL;
        bindBufferRange                = &glBindBufferRangeNULL;
        bindSampler                    = &glBindSamplerNULL;
        bindTransformFeedback          = &glBindTransformFeedbackNULL;
        bindVertexArray                = &glBindVertexArrayNULL;
        blitFramebuffer                = &glBlitFramebufferNULL;
        clearBufferfi                  = &glClearBufferfiNULL;
        clearBufferfv                  = &glClearBufferfvNULL;
        clearBufferiv                  = &glClearBufferivNULL;
        clearBufferuiv                 = &glClearBufferuivNULL;
        clientWaitSync                 = &glClientWaitSyncNULL;
        compressedTexImage3D           = &glCompressedTexImage3DNULL;
        compressedTexSubImage3D        = &glCompressedTexSubImage3DNULL;
        copyBufferSubData              = &glCopyBufferSubDataNULL;
        copyTexSubImage3D              = &glCopyTexSubImage3DNULL;
        deleteQueries                  = &glDeleteQueriesNULL;
        deleteSamplers                 = &glDeleteSamplersNULL;
        deleteSync                     = &glDeleteSyncNULL;
        deleteTransformFeedbacks       = &glDeleteTransformFeedbacksNULL;
        deleteVertexArrays             = &glDeleteVertexArraysNULL;
        drawArraysInstanced            = &glDrawArraysInstancedNULL;
        drawBuffers                    = &glDrawBuffersNULL;
        drawElementsInstanced          = &glDrawElementsInstancedNULL;
        drawRangeElements              = &glDrawRangeElementsNULL;
        endQuery                       = &glEndQueryNULL;
        endTransformFeedback           = &glEndTransformFeedbackNULL;
        fenceSync                      = &glFenceSyncNULL;
        flushMappedBufferRange         = &glFlushMappedBufferRangeNULL;
        framebufferTextureLayer        = &glFramebufferTextureLayerNULL;
        genQueries                     = &glGenQueriesNULL;
        genSamplers                    = &glGenSamplersNULL;
        genTransformFeedbacks          = &glGenTransformFeedbacksNULL;
        genVertexArrays                = &glGenVertexArraysNULL;
        getActiveUniformBlockName      = &glGetActiveUniformBlockNameNULL;
        getActiveUniformBlockiv        = &glGetActiveUniformBlockivNULL;
        getActiveUniformsiv            = &glGetActiveUniformsivNULL;
        getBufferParameteri64v         = &glGetBufferParameteri64vNULL;
        getBufferPointerv              = &glGetBufferPointervNULL;
        getFragDataLocation            = &glGetFragDataLocationNULL;
        getInteger64i_v                = &glGetInteger64i_vNULL;
        getInteger64v                  = &glGetInteger64vNULL;
        getIntegeri_v                  = &glGetIntegeri_vNULL;
        getInternalformativ            = &glGetInternalformativNULL;
        getProgramBinary               = &glGetProgramBinaryNULL;
        getQueryObjectuiv              = &glGetQueryObjectuivNULL;
        getQueryiv                     = &glGetQueryivNULL;
        getSamplerParameterfv          = &glGetSamplerParameterfvNULL;
        getSamplerParameteriv          = &glGetSamplerParameterivNULL;
        getStringi                     = &glGetStringiNULL;
        getSynciv                      = &glGetSyncivNULL;
        getTransformFeedbackVarying    = &glGetTransformFeedbackVaryingNULL;
        getUniformBlockIndex           = &glGetUniformBlockIndexNULL;
        getUniformIndices              = &glGetUniformIndicesNULL;
        getUniformuiv                  = &glGetUniformuivNULL;
        getVertexAttribIiv             = &glGetVertexAttribIivNULL;
        getVertexAttribIuiv            = &glGetVertexAttribIuivNULL;
        invalidateFramebuffer          = &glInvalidateFramebufferNULL;
        invalidateSubFramebuffer       = &glInvalidateSubFramebufferNULL;
        isQuery                        = &glIsQueryNULL;
        isSampler                      = &glIsSamplerNULL;
        isSync                         = &glIsSyncNULL;
        isTransformFeedback            = &glIsTransformFeedbackNULL;
        isVertexArray                  = &glIsVertexArrayNULL;
        mapBufferRange                 = &glMapBufferRangeNULL;
        pauseTransformFeedback         = &glPauseTransformFeedbackNULL;
        programBinary                  = &glProgramBinaryNULL;
        programParameteri              = &glProgramParameteriNULL;
        readBuffer                     = &glReadBufferNULL;
        renderbufferStorageMultisample = &glRenderbufferStorageMultisampleNULL;
        resumeTransformFeedback        = &glResumeTransformFeedbackNULL;
        samplerParameterf              = &glSamplerParameterfNULL;
        samplerParameterfv             = &glSamplerParameterfvNULL;
        samplerParameteri              = &glSamplerParameteriNULL;
        samplerParameteriv             = &glSamplerParameterivNULL;
        texImage3D                     = &glTexImage3DNULL;
        texStorage2D                   = &glTexStorage2DNULL;
        texStorage3D                   = &glTexStorage3DNULL;
        texSubImage3D                  = &glTexSubImage3DNULL;
        transformFeedbackVaryings      = &glTransformFeedbackVaryingsNULL;
        uniform1ui                     = &glUniform1uiNULL;
        uniform1uiv                    = &glUniform1uivNULL;
        uniform2ui                     = &glUniform2uiNULL;
        uniform2uiv                    = &glUniform2uivNULL;
        uniform3ui                     = &glUniform3uiNULL;
        uniform3uiv                    = &glUniform3uivNULL;
        uniform4ui                     = &glUniform4uiNULL;
        uniform4uiv                    = &glUniform4uivNULL;
        uniformBlockBinding            = &glUniformBlockBindingNULL;
        uniformMatrix2x3fv             = &glUniformMatrix2x3fvNULL;
        uniformMatrix2x4fv             = &glUniformMatrix2x4fvNULL;
        uniformMatrix3x2fv             = &glUniformMatrix3x2fvNULL;
        uniformMatrix3x4fv             = &glUniformMatrix3x4fvNULL;
        uniformMatrix4x2fv             = &glUniformMatrix4x2fvNULL;
        uniformMatrix4x3fv             = &glUniformMatrix4x3fvNULL;
        unmapBuffer                    = &glUnmapBufferNULL;
        vertexAttribDivisor            = &glVertexAttribDivisorNULL;
        vertexAttribI4i                = &glVertexAttribI4iNULL;
        vertexAttribI4iv               = &glVertexAttribI4ivNULL;
        vertexAttribI4ui               = &glVertexAttribI4uiNULL;
        vertexAttribI4uiv              = &glVertexAttribI4uivNULL;
        vertexAttribIPointer           = &glVertexAttribIPointerNULL;
        waitSync                       = &glWaitSyncNULL;
    }

    if (version >= gl::Version(3, 1))
    {
        activeShaderProgram        = &glActiveShaderProgramNULL;
        bindImageTexture           = &glBindImageTextureNULL;
        bindProgramPipeline        = &glBindProgramPipelineNULL;
        bindVertexBuffer           = &glBindVertexBufferNULL;
        createShaderProgramv       = &glCreateShaderProgramvNULL;
        deleteProgramPipelines     = &glDeleteProgramPipelinesNULL;
        dispatchCompute            = &glDispatchComputeNULL;
        dispatchComputeIndirect    = &glDispatchComputeIndirectNULL;
        drawArraysIndirect         = &glDrawArraysIndirectNULL;
        drawElementsIndirect       = &glDrawElementsIndirectNULL;
        framebufferParameteri      = &glFramebufferParameteriNULL;
        genProgramPipelines        = &glGenProgramPipelinesNULL;
        getBooleani_v              = &glGetBooleani_vNULL;
        getFramebufferParameteriv  = &glGetFramebufferParameterivNULL;
        getMultisamplefv           = &glGetMultisamplefvNULL;
        getProgramInterfaceiv      = &glGetProgramInterfaceivNULL;
        getProgramPipelineInfoLog  = &glGetProgramPipelineInfoLogNULL;
        getProgramPipelineiv       = &glGetProgramPipelineivNULL;
        getProgramResourceIndex    = &glGetProgramResourceIndexNULL;
        getProgramResourceLocation = &glGetProgramResourceLocationNULL;
        getProgramResourceName     = &glGetProgramResourceNameNULL;
        getProgramResourceiv       = &glGetProgramResourceivNULL;
        getTexLevelParameterfv     = &glGetTexLevelParameterfvNULL;
        getTexLevelParameteriv     = &glGetTexLevelParameterivNULL;
        isProgramPipeline          = &glIsProgramPipelineNULL;
        memoryBarrier              = &glMemoryBarrierNULL;
        memoryBarrierByRegion      = &glMemoryBarrierByRegionNULL;
        programUniform1f           = &glProgramUniform1fNULL;
        programUniform1fv          = &glProgramUniform1fvNULL;
        programUniform1i           = &glProgramUniform1iNULL;
        programUniform1iv          = &glProgramUniform1ivNULL;
        programUniform1ui          = &glProgramUniform1uiNULL;
        programUniform1uiv         = &glProgramUniform1uivNULL;
        programUniform2f           = &glProgramUniform2fNULL;
        programUniform2fv          = &glProgramUniform2fvNULL;
        programUniform2i           = &glProgramUniform2iNULL;
        programUniform2iv          = &glProgramUniform2ivNULL;
        programUniform2ui          = &glProgramUniform2uiNULL;
        programUniform2uiv         = &glProgramUniform2uivNULL;
        programUniform3f           = &glProgramUniform3fNULL;
        programUniform3fv          = &glProgramUniform3fvNULL;
        programUniform3i           = &glProgramUniform3iNULL;
        programUniform3iv          = &glProgramUniform3ivNULL;
        programUniform3ui          = &glProgramUniform3uiNULL;
        programUniform3uiv         = &glProgramUniform3uivNULL;
        programUniform4f           = &glProgramUniform4fNULL;
        programUniform4fv          = &glProgramUniform4fvNULL;
        programUniform4i           = &glProgramUniform4iNULL;
        programUniform4iv          = &glProgramUniform4ivNULL;
        programUniform4ui          = &glProgramUniform4uiNULL;
        programUniform4uiv         = &glProgramUniform4uivNULL;
        programUniformMatrix2fv    = &glProgramUniformMatrix2fvNULL;
        programUniformMatrix2x3fv  = &glProgramUniformMatrix2x3fvNULL;
        programUniformMatrix2x4fv  = &glProgramUniformMatrix2x4fvNULL;
        programUniformMatrix3fv    = &glProgramUniformMatrix3fvNULL;
        programUniformMatrix3x2fv  = &glProgramUniformMatrix3x2fvNULL;
        programUniformMatrix3x4fv  = &glProgramUniformMatrix3x4fvNULL;
        programUniformMatrix4fv    = &glProgramUniformMatrix4fvNULL;
        programUniformMatrix4x2fv  = &glProgramUniformMatrix4x2fvNULL;
        programUniformMatrix4x3fv  = &glProgramUniformMatrix4x3fvNULL;
        sampleMaski                = &glSampleMaskiNULL;
        texStorage2DMultisample    = &glTexStorage2DMultisampleNULL;
        useProgramStages           = &glUseProgramStagesNULL;
        validateProgramPipeline    = &glValidateProgramPipelineNULL;
        vertexAttribBinding        = &glVertexAttribBindingNULL;
        vertexAttribFormat         = &glVertexAttribFormatNULL;
        vertexAttribIFormat        = &glVertexAttribIFormatNULL;
        vertexBindingDivisor       = &glVertexBindingDivisorNULL;
    }

    if (version >= gl::Version(3, 2))
    {
        blendBarrier                    = &glBlendBarrierNULL;
        blendEquationSeparatei          = &glBlendEquationSeparateiNULL;
        blendEquationi                  = &glBlendEquationiNULL;
        blendFuncSeparatei              = &glBlendFuncSeparateiNULL;
        blendFunci                      = &glBlendFunciNULL;
        colorMaski                      = &glColorMaskiNULL;
        copyImageSubData                = &glCopyImageSubDataNULL;
        debugMessageCallback            = &glDebugMessageCallbackNULL;
        debugMessageControl             = &glDebugMessageControlNULL;
        debugMessageInsert              = &glDebugMessageInsertNULL;
        disablei                        = &glDisableiNULL;
        drawElementsBaseVertex          = &glDrawElementsBaseVertexNULL;
        drawElementsInstancedBaseVertex = &glDrawElementsInstancedBaseVertexNULL;
        drawRangeElementsBaseVertex     = &glDrawRangeElementsBaseVertexNULL;
        enablei                         = &glEnableiNULL;
        framebufferTexture              = &glFramebufferTextureNULL;
        getDebugMessageLog              = &glGetDebugMessageLogNULL;
        getGraphicsResetStatus          = &glGetGraphicsResetStatusNULL;
        getObjectLabel                  = &glGetObjectLabelNULL;
        getObjectPtrLabel               = &glGetObjectPtrLabelNULL;
        getPointerv                     = &glGetPointervNULL;
        getSamplerParameterIiv          = &glGetSamplerParameterIivNULL;
        getSamplerParameterIuiv         = &glGetSamplerParameterIuivNULL;
        getTexParameterIiv              = &glGetTexParameterIivNULL;
        getTexParameterIuiv             = &glGetTexParameterIuivNULL;
        getnUniformfv                   = &glGetnUniformfvNULL;
        getnUniformiv                   = &glGetnUniformivNULL;
        getnUniformuiv                  = &glGetnUniformuivNULL;
        isEnabledi                      = &glIsEnablediNULL;
        minSampleShading                = &glMinSampleShadingNULL;
        objectLabel                     = &glObjectLabelNULL;
        objectPtrLabel                  = &glObjectPtrLabelNULL;
        patchParameteri                 = &glPatchParameteriNULL;
        popDebugGroup                   = &glPopDebugGroupNULL;
        primitiveBoundingBox            = &glPrimitiveBoundingBoxNULL;
        pushDebugGroup                  = &glPushDebugGroupNULL;
        readnPixels                     = &glReadnPixelsNULL;
        samplerParameterIiv             = &glSamplerParameterIivNULL;
        samplerParameterIuiv            = &glSamplerParameterIuivNULL;
        texBuffer                       = &glTexBufferNULL;
        texBufferRange                  = &glTexBufferRangeNULL;
        texParameterIiv                 = &glTexParameterIivNULL;
        texParameterIuiv                = &glTexParameterIuivNULL;
        texStorage3DMultisample         = &glTexStorage3DMultisampleNULL;
    }

    if (extensions.count("GL_EXT_base_instance") != 0)
    {
        drawArraysInstancedBaseInstance   = &glDrawArraysInstancedBaseInstanceNULL;
        drawElementsInstancedBaseInstance = &glDrawElementsInstancedBaseInstanceNULL;
        drawElementsInstancedBaseVertexBaseInstance =
            &glDrawElementsInstancedBaseVertexBaseInstanceNULL;
    }

    if (extensions.count("GL_EXT_blend_func_extended") != 0)
    {
        bindFragDataLocation            = &glBindFragDataLocationNULL;
        bindFragDataLocationIndexed     = &glBindFragDataLocationIndexedNULL;
        getFragDataIndex                = &glGetFragDataIndexNULL;
        getProgramResourceLocationIndex = &glGetProgramResourceLocationIndexNULL;
    }

    if (extensions.count("GL_EXT_buffer_storage") != 0)
    {
        bufferStorage = &glBufferStorageNULL;
    }

    if (extensions.count("GL_EXT_clear_texture") != 0)
    {
        clearTexImage    = &glClearTexImageNULL;
        clearTexSubImage = &glClearTexSubImageNULL;
    }

    if (extensions.count("GL_EXT_clip_control") != 0)
    {
        clipControl = &glClipControlNULL;
    }

    if (extensions.count("GL_EXT_copy_image") != 0)
    {
        copyImageSubData = &glCopyImageSubDataNULL;
    }

    if (extensions.count("GL_EXT_discard_framebuffer") != 0)
    {
        discardFramebufferEXT = &glDiscardFramebufferEXTNULL;
    }

    if (extensions.count("GL_EXT_disjoint_timer_query") != 0)
    {
        beginQuery          = &glBeginQueryNULL;
        deleteQueries       = &glDeleteQueriesNULL;
        endQuery            = &glEndQueryNULL;
        genQueries          = &glGenQueriesNULL;
        getQueryObjecti64v  = &glGetQueryObjecti64vNULL;
        getQueryObjectiv    = &glGetQueryObjectivNULL;
        getQueryObjectui64v = &glGetQueryObjectui64vNULL;
        getQueryObjectuiv   = &glGetQueryObjectuivNULL;
        getQueryiv          = &glGetQueryivNULL;
        isQuery             = &glIsQueryNULL;
        queryCounter        = &glQueryCounterNULL;
    }

    if (extensions.count("GL_EXT_draw_buffers") != 0)
    {
        drawBuffers = &glDrawBuffersNULL;
    }

    if (extensions.count("GL_EXT_draw_buffers_indexed") != 0)
    {
        blendEquationSeparatei = &glBlendEquationSeparateiNULL;
        blendEquationi         = &glBlendEquationiNULL;
        blendFuncSeparatei     = &glBlendFuncSeparateiNULL;
        blendFunci             = &glBlendFunciNULL;
        colorMaski             = &glColorMaskiNULL;
        disablei               = &glDisableiNULL;
        enablei                = &glEnableiNULL;
        isEnabledi             = &glIsEnablediNULL;
    }

    if (extensions.count("GL_EXT_draw_elements_base_vertex") != 0)
    {
        drawElementsBaseVertex          = &glDrawElementsBaseVertexNULL;
        drawElementsInstancedBaseVertex = &glDrawElementsInstancedBaseVertexNULL;
        drawRangeElementsBaseVertex     = &glDrawRangeElementsBaseVertexNULL;
        multiDrawElementsBaseVertex     = &glMultiDrawElementsBaseVertexNULL;
    }

    if (extensions.count("GL_EXT_draw_transform_feedback") != 0)
    {
        drawTransformFeedback          = &glDrawTransformFeedbackNULL;
        drawTransformFeedbackInstanced = &glDrawTransformFeedbackInstancedNULL;
    }

    if (extensions.count("GL_EXT_geometry_shader") != 0)
    {
        framebufferTexture = &glFramebufferTextureNULL;
    }

    if (extensions.count("GL_EXT_instanced_arrays") != 0)
    {
        vertexAttribDivisor = &glVertexAttribDivisorNULL;
    }

    if (extensions.count("GL_EXT_map_buffer_range") != 0)
    {
        flushMappedBufferRange = &glFlushMappedBufferRangeNULL;
        mapBufferRange         = &glMapBufferRangeNULL;
    }

    if (extensions.count("GL_EXT_multi_draw_indirect") != 0)
    {
        multiDrawArraysIndirect   = &glMultiDrawArraysIndirectNULL;
        multiDrawElementsIndirect = &glMultiDrawElementsIndirectNULL;
    }

    if (extensions.count("GL_EXT_multisampled_render_to_texture") != 0)
    {
        renderbufferStorageMultisample = &glRenderbufferStorageMultisampleNULL;
    }

    if (extensions.count("GL_EXT_multiview_draw_buffers") != 0)
    {
        getIntegeri_v = &glGetIntegeri_vNULL;
    }

    if (extensions.count("GL_EXT_occlusion_query_boolean") != 0)
    {
        beginQuery        = &glBeginQueryNULL;
        deleteQueries     = &glDeleteQueriesNULL;
        endQuery          = &glEndQueryNULL;
        genQueries        = &glGenQueriesNULL;
        getQueryObjectuiv = &glGetQueryObjectuivNULL;
        getQueryiv        = &glGetQueryivNULL;
        isQuery           = &glIsQueryNULL;
    }

    if (extensions.count("GL_EXT_primitive_bounding_box") != 0)
    {
        primitiveBoundingBox = &glPrimitiveBoundingBoxNULL;
    }

    if (extensions.count("GL_EXT_robustness") != 0)
    {
        getGraphicsResetStatus = &glGetGraphicsResetStatusNULL;
        getnUniformfv          = &glGetnUniformfvNULL;
        getnUniformiv          = &glGetnUniformivNULL;
        readnPixels            = &glReadnPixelsNULL;
    }

    if (extensions.count("GL_EXT_tessellation_shader") != 0)
    {
        patchParameteri = &glPatchParameteriNULL;
    }

    if (extensions.count("GL_EXT_texture_border_clamp") != 0)
    {
        getSamplerParameterIiv  = &glGetSamplerParameterIivNULL;
        getSamplerParameterIuiv = &glGetSamplerParameterIuivNULL;
        getTexParameterIiv      = &glGetTexParameterIivNULL;
        getTexParameterIuiv     = &glGetTexParameterIuivNULL;
        samplerParameterIiv     = &glSamplerParameterIivNULL;
        samplerParameterIuiv    = &glSamplerParameterIuivNULL;
        texParameterIiv         = &glTexParameterIivNULL;
        texParameterIuiv        = &glTexParameterIuivNULL;
    }

    if (extensions.count("GL_EXT_texture_buffer") != 0)
    {
        texBuffer      = &glTexBufferNULL;
        texBufferRange = &glTexBufferRangeNULL;
    }

    if (extensions.count("GL_EXT_texture_storage") != 0)
    {
        texStorage1D     = &glTexStorage1DNULL;
        texStorage2D     = &glTexStorage2DNULL;
        texStorage3D     = &glTexStorage3DNULL;
        textureStorage1D = &glTextureStorage1DNULL;
        textureStorage2D = &glTextureStorage2DNULL;
        textureStorage3D = &glTextureStorage3DNULL;
    }

    if (extensions.count("GL_EXT_texture_view") != 0)
    {
        textureView = &glTextureViewNULL;
    }

    if (extensions.count("GL_KHR_debug") != 0)
    {
        debugMessageCallback = &glDebugMessageCallbackNULL;
        debugMessageControl  = &glDebugMessageControlNULL;
        debugMessageInsert   = &glDebugMessageInsertNULL;
        getDebugMessageLog   = &glGetDebugMessageLogNULL;
        getObjectLabel       = &glGetObjectLabelNULL;
        getObjectPtrLabel    = &glGetObjectPtrLabelNULL;
        getPointerv          = &glGetPointervNULL;
        objectLabel          = &glObjectLabelNULL;
        objectPtrLabel       = &glObjectPtrLabelNULL;
        popDebugGroup        = &glPopDebugGroupNULL;
        pushDebugGroup       = &glPushDebugGroupNULL;
    }

    if (extensions.count("GL_KHR_robustness") != 0)
    {
        getGraphicsResetStatus = &glGetGraphicsResetStatusNULL;
        getnUniformfv          = &glGetnUniformfvNULL;
        getnUniformiv          = &glGetnUniformivNULL;
        getnUniformuiv         = &glGetnUniformuivNULL;
        readnPixels            = &glReadnPixelsNULL;
    }

    if (extensions.count("GL_OES_EGL_image") != 0)
    {
        eGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOESNULL;
        eGLImageTargetTexture2DOES           = &glEGLImageTargetTexture2DOESNULL;
    }

    if (extensions.count("GL_OES_copy_image") != 0)
    {
        copyImageSubData = &glCopyImageSubDataNULL;
    }

    if (extensions.count("GL_OES_draw_buffers_indexed") != 0)
    {
        blendEquationSeparatei = &glBlendEquationSeparateiNULL;
        blendEquationi         = &glBlendEquationiNULL;
        blendFuncSeparatei     = &glBlendFuncSeparateiNULL;
        blendFunci             = &glBlendFunciNULL;
        colorMaski             = &glColorMaskiNULL;
        disablei               = &glDisableiNULL;
        enablei                = &glEnableiNULL;
        isEnabledi             = &glIsEnablediNULL;
    }

    if (extensions.count("GL_OES_draw_elements_base_vertex") != 0)
    {
        drawElementsBaseVertex          = &glDrawElementsBaseVertexNULL;
        drawElementsInstancedBaseVertex = &glDrawElementsInstancedBaseVertexNULL;
        drawRangeElementsBaseVertex     = &glDrawRangeElementsBaseVertexNULL;
        multiDrawElementsBaseVertex     = &glMultiDrawElementsBaseVertexNULL;
    }

    if (extensions.count("GL_OES_geometry_shader") != 0)
    {
        framebufferTexture = &glFramebufferTextureNULL;
    }

    if (extensions.count("GL_OES_get_program_binary") != 0)
    {
        getProgramBinary = &glGetProgramBinaryNULL;
        programBinary    = &glProgramBinaryNULL;
    }

    if (extensions.count("GL_OES_mapbuffer") != 0)
    {
        getBufferPointerv = &glGetBufferPointervNULL;
        mapBuffer         = &glMapBufferNULL;
        unmapBuffer       = &glUnmapBufferNULL;
    }

    if (extensions.count("GL_OES_primitive_bounding_box") != 0)
    {
        primitiveBoundingBox = &glPrimitiveBoundingBoxNULL;
    }

    if (extensions.count("GL_OES_sample_shading") != 0)
    {
        minSampleShading = &glMinSampleShadingNULL;
    }

    if (extensions.count("GL_OES_tessellation_shader") != 0)
    {
        patchParameteri = &glPatchParameteriNULL;
    }

    if (extensions.count("GL_OES_texture_3D") != 0)
    {
        compressedTexImage3D    = &glCompressedTexImage3DNULL;
        compressedTexSubImage3D = &glCompressedTexSubImage3DNULL;
        copyTexSubImage3D       = &glCopyTexSubImage3DNULL;
        framebufferTexture3D    = &glFramebufferTexture3DNULL;
        texImage3D              = &glTexImage3DNULL;
        texSubImage3D           = &glTexSubImage3DNULL;
    }

    if (extensions.count("GL_OES_texture_border_clamp") != 0)
    {
        getSamplerParameterIiv  = &glGetSamplerParameterIivNULL;
        getSamplerParameterIuiv = &glGetSamplerParameterIuivNULL;
        getTexParameterIiv      = &glGetTexParameterIivNULL;
        getTexParameterIuiv     = &glGetTexParameterIuivNULL;
        samplerParameterIiv     = &glSamplerParameterIivNULL;
        samplerParameterIuiv    = &glSamplerParameterIuivNULL;
        texParameterIiv         = &glTexParameterIivNULL;
        texParameterIuiv        = &glTexParameterIuivNULL;
    }

    if (extensions.count("GL_OES_texture_buffer") != 0)
    {
        texBuffer      = &glTexBufferNULL;
        texBufferRange = &glTexBufferRangeNULL;
    }

    if (extensions.count("GL_OES_texture_storage_multisample_2d_array") != 0)
    {
        texStorage3DMultisample = &glTexStorage3DMultisampleNULL;
    }

    if (extensions.count("GL_OES_texture_view") != 0)
    {
        textureView = &glTextureViewNULL;
    }

    if (extensions.count("GL_OES_vertex_array_object") != 0)
    {
        bindVertexArray    = &glBindVertexArrayNULL;
        deleteVertexArrays = &glDeleteVertexArraysNULL;
        genVertexArrays    = &glGenVertexArraysNULL;
        isVertexArray      = &glIsVertexArrayNULL;
    }

    if (extensions.count("GL_OES_viewport_array") != 0)
    {
        disablei          = &glDisableiNULL;
        enablei           = &glEnableiNULL;
        getFloati_v       = &glGetFloati_vNULL;
        isEnabledi        = &glIsEnablediNULL;
        scissorArrayv     = &glScissorArrayvNULL;
        scissorIndexed    = &glScissorIndexedNULL;
        scissorIndexedv   = &glScissorIndexedvNULL;
        viewportArrayv    = &glViewportArrayvNULL;
        viewportIndexedf  = &glViewportIndexedfNULL;
        viewportIndexedfv = &glViewportIndexedfvNULL;
    }
}

void DispatchTableGL::initProcsSharedExtensionsNULL(const std::set<std::string> &extensions)
{
    if (extensions.count("GL_EXT_blend_minmax") != 0)
    {
        blendEquation = &glBlendEquationNULL;
    }

    if (extensions.count("GL_EXT_debug_label") != 0)
    {
        getObjectLabel = &glGetObjectLabelNULL;
    }

    if (extensions.count("GL_EXT_debug_marker") != 0)
    {
        insertEventMarkerEXT = &glInsertEventMarkerEXTNULL;
        popGroupMarkerEXT    = &glPopGroupMarkerEXTNULL;
        pushGroupMarkerEXT   = &glPushGroupMarkerEXTNULL;
    }

    if (extensions.count("GL_EXT_draw_instanced") != 0)
    {
        drawArraysInstanced   = &glDrawArraysInstancedNULL;
        drawElementsInstanced = &glDrawElementsInstancedNULL;
    }

    if (extensions.count("GL_EXT_memory_object") != 0)
    {
        bufferStorageMemEXT               = &glBufferStorageMemEXTNULL;
        createMemoryObjectsEXT            = &glCreateMemoryObjectsEXTNULL;
        deleteMemoryObjectsEXT            = &glDeleteMemoryObjectsEXTNULL;
        getMemoryObjectParameterivEXT     = &glGetMemoryObjectParameterivEXTNULL;
        getUnsignedBytei_vEXT             = &glGetUnsignedBytei_vEXTNULL;
        getUnsignedBytevEXT               = &glGetUnsignedBytevEXTNULL;
        isMemoryObjectEXT                 = &glIsMemoryObjectEXTNULL;
        memoryObjectParameterivEXT        = &glMemoryObjectParameterivEXTNULL;
        namedBufferStorageMemEXT          = &glNamedBufferStorageMemEXTNULL;
        texStorageMem2DEXT                = &glTexStorageMem2DEXTNULL;
        texStorageMem2DMultisampleEXT     = &glTexStorageMem2DMultisampleEXTNULL;
        texStorageMem3DEXT                = &glTexStorageMem3DEXTNULL;
        texStorageMem3DMultisampleEXT     = &glTexStorageMem3DMultisampleEXTNULL;
        textureStorageMem2DEXT            = &glTextureStorageMem2DEXTNULL;
        textureStorageMem2DMultisampleEXT = &glTextureStorageMem2DMultisampleEXTNULL;
        textureStorageMem3DEXT            = &glTextureStorageMem3DEXTNULL;
        textureStorageMem3DMultisampleEXT = &glTextureStorageMem3DMultisampleEXTNULL;
    }

    if (extensions.count("GL_EXT_memory_object_fd") != 0)
    {
        importMemoryFdEXT = &glImportMemoryFdEXTNULL;
    }

    if (extensions.count("GL_EXT_memory_object_win32") != 0)
    {
        importMemoryWin32HandleEXT = &glImportMemoryWin32HandleEXTNULL;
        importMemoryWin32NameEXT   = &glImportMemoryWin32NameEXTNULL;
    }

    if (extensions.count("GL_EXT_multi_draw_arrays") != 0)
    {
        multiDrawArrays   = &glMultiDrawArraysNULL;
        multiDrawElements = &glMultiDrawElementsNULL;
    }

    if (extensions.count("GL_EXT_semaphore") != 0)
    {
        deleteSemaphoresEXT           = &glDeleteSemaphoresEXTNULL;
        genSemaphoresEXT              = &glGenSemaphoresEXTNULL;
        getSemaphoreParameterui64vEXT = &glGetSemaphoreParameterui64vEXTNULL;
        getUnsignedBytei_vEXT         = &glGetUnsignedBytei_vEXTNULL;
        getUnsignedBytevEXT           = &glGetUnsignedBytevEXTNULL;
        isSemaphoreEXT                = &glIsSemaphoreEXTNULL;
        semaphoreParameterui64vEXT    = &glSemaphoreParameterui64vEXTNULL;
        signalSemaphoreEXT            = &glSignalSemaphoreEXTNULL;
        waitSemaphoreEXT              = &glWaitSemaphoreEXTNULL;
    }

    if (extensions.count("GL_EXT_semaphore_fd") != 0)
    {
        importSemaphoreFdEXT = &glImportSemaphoreFdEXTNULL;
    }

    if (extensions.count("GL_EXT_semaphore_win32") != 0)
    {
        importSemaphoreWin32HandleEXT = &glImportSemaphoreWin32HandleEXTNULL;
        importSemaphoreWin32NameEXT   = &glImportSemaphoreWin32NameEXTNULL;
    }

    if (extensions.count("GL_EXT_separate_shader_objects") != 0)
    {
        activeShaderProgram       = &glActiveShaderProgramNULL;
        bindProgramPipeline       = &glBindProgramPipelineNULL;
        createShaderProgramv      = &glCreateShaderProgramvNULL;
        deleteProgramPipelines    = &glDeleteProgramPipelinesNULL;
        genProgramPipelines       = &glGenProgramPipelinesNULL;
        getProgramPipelineInfoLog = &glGetProgramPipelineInfoLogNULL;
        getProgramPipelineiv      = &glGetProgramPipelineivNULL;
        isProgramPipeline         = &glIsProgramPipelineNULL;
        programParameteri         = &glProgramParameteriNULL;
        programUniform1f          = &glProgramUniform1fNULL;
        programUniform1fv         = &glProgramUniform1fvNULL;
        programUniform1i          = &glProgramUniform1iNULL;
        programUniform1iv         = &glProgramUniform1ivNULL;
        programUniform1ui         = &glProgramUniform1uiNULL;
        programUniform1uiv        = &glProgramUniform1uivNULL;
        programUniform2f          = &glProgramUniform2fNULL;
        programUniform2fv         = &glProgramUniform2fvNULL;
        programUniform2i          = &glProgramUniform2iNULL;
        programUniform2iv         = &glProgramUniform2ivNULL;
        programUniform2ui         = &glProgramUniform2uiNULL;
        programUniform2uiv        = &glProgramUniform2uivNULL;
        programUniform3f          = &glProgramUniform3fNULL;
        programUniform3fv         = &glProgramUniform3fvNULL;
        programUniform3i          = &glProgramUniform3iNULL;
        programUniform3iv         = &glProgramUniform3ivNULL;
        programUniform3ui         = &glProgramUniform3uiNULL;
        programUniform3uiv        = &glProgramUniform3uivNULL;
        programUniform4f          = &glProgramUniform4fNULL;
        programUniform4fv         = &glProgramUniform4fvNULL;
        programUniform4i          = &glProgramUniform4iNULL;
        programUniform4iv         = &glProgramUniform4ivNULL;
        programUniform4ui         = &glProgramUniform4uiNULL;
        programUniform4uiv        = &glProgramUniform4uivNULL;
        programUniformMatrix2fv   = &glProgramUniformMatrix2fvNULL;
        programUniformMatrix2x3fv = &glProgramUniformMatrix2x3fvNULL;
        programUniformMatrix2x4fv = &glProgramUniformMatrix2x4fvNULL;
        programUniformMatrix3fv   = &glProgramUniformMatrix3fvNULL;
        programUniformMatrix3x2fv = &glProgramUniformMatrix3x2fvNULL;
        programUniformMatrix3x4fv = &glProgramUniformMatrix3x4fvNULL;
        programUniformMatrix4fv   = &glProgramUniformMatrix4fvNULL;
        programUniformMatrix4fv   = &glProgramUniformMatrix4fvNULL;
        programUniformMatrix4x2fv = &glProgramUniformMatrix4x2fvNULL;
        programUniformMatrix4x3fv = &glProgramUniformMatrix4x3fvNULL;
        useProgramStages          = &glUseProgramStagesNULL;
        validateProgramPipeline   = &glValidateProgramPipelineNULL;
    }

    if (extensions.count("GL_KHR_parallel_shader_compile") != 0)
    {
        maxShaderCompilerThreadsKHR = &glMaxShaderCompilerThreadsKHRNULL;
    }

    if (extensions.count("GL_NV_fence") != 0)
    {
        deleteFencesNV = &glDeleteFencesNVNULL;
        finishFenceNV  = &glFinishFenceNVNULL;
        genFencesNV    = &glGenFencesNVNULL;
        getFenceivNV   = &glGetFenceivNVNULL;
        isFenceNV      = &glIsFenceNVNULL;
        setFenceNV     = &glSetFenceNVNULL;
        testFenceNV    = &glTestFenceNVNULL;
    }

    if (extensions.count("GL_NV_framebuffer_mixed_samples") != 0)
    {
        coverageModulationNV = &glCoverageModulationNVNULL;
    }

    if (extensions.count("GL_NV_internalformat_sample_query") != 0)
    {
        getInternalformatSampleivNV = &glGetInternalformatSampleivNVNULL;
    }

    if (extensions.count("GL_NV_path_rendering") != 0)
    {
        coverFillPathInstancedNV              = &glCoverFillPathInstancedNVNULL;
        coverFillPathNV                       = &glCoverFillPathNVNULL;
        coverStrokePathInstancedNV            = &glCoverStrokePathInstancedNVNULL;
        coverStrokePathNV                     = &glCoverStrokePathNVNULL;
        deletePathsNV                         = &glDeletePathsNVNULL;
        genPathsNV                            = &glGenPathsNVNULL;
        getPathParameterfvNV                  = &glGetPathParameterfvNVNULL;
        getPathParameterivNV                  = &glGetPathParameterivNVNULL;
        isPathNV                              = &glIsPathNVNULL;
        matrixLoadfEXT                        = &glMatrixLoadfEXTNULL;
        pathCommandsNV                        = &glPathCommandsNVNULL;
        pathParameterfNV                      = &glPathParameterfNVNULL;
        pathParameteriNV                      = &glPathParameteriNVNULL;
        pathStencilFuncNV                     = &glPathStencilFuncNVNULL;
        programPathFragmentInputGenNV         = &glProgramPathFragmentInputGenNVNULL;
        stencilFillPathInstancedNV            = &glStencilFillPathInstancedNVNULL;
        stencilFillPathNV                     = &glStencilFillPathNVNULL;
        stencilStrokePathInstancedNV          = &glStencilStrokePathInstancedNVNULL;
        stencilStrokePathNV                   = &glStencilStrokePathNVNULL;
        stencilThenCoverFillPathInstancedNV   = &glStencilThenCoverFillPathInstancedNVNULL;
        stencilThenCoverFillPathNV            = &glStencilThenCoverFillPathNVNULL;
        stencilThenCoverStrokePathInstancedNV = &glStencilThenCoverStrokePathInstancedNVNULL;
        stencilThenCoverStrokePathNV          = &glStencilThenCoverStrokePathNVNULL;
    }

    if (extensions.count("GL_OVR_multiview") != 0)
    {
        framebufferTextureMultiviewOVR = &glFramebufferTextureMultiviewOVRNULL;
    }
}
#endif  // defined(ANGLE_ENABLE_OPENGL_NULL)

}  // namespace rx