kc3-lang/angle/src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp

• Show log

  Commit

• Hash : 73f9cf00
  Author :
  Date : 2023-03-31T00:00:00
  

  GL: Implement polygon mode extensions
  
  * Implemented polygon mode extensions
    on the OpenGL backend
  
  * Supported capture and serialization
    of the new commands and state
  
  * Added PolygonModeTest end2end tests
  
  Bug: angleproject:1791
  Bug: angleproject:8132
  Change-Id: I3bc08546a02f110dd739950129bee25ccc507bf6
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4492683
  Commit-Queue: Alexey Knyazev <lexa.knyazev@gmail.com>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp

• // GENERATED FILE - DO NOT EDIT.
  // Generated by generate_gl_dispatch_table.py using data from gl_bindings_data.json and gl.xml.
  //
  // Copyright 2017 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)
  
  #define ASSIGN(NAME, FP)                                            \
      do                                                              \
      {                                                               \
          FP = reinterpret_cast<decltype(FP)>(loadProcAddress(NAME)); \
      } while (0)
  
  namespace rx
  {
  DispatchTableGL::DispatchTableGL() = default;
  
  void DispatchTableGL::initProcsDesktopGL(const gl::Version &version,
                                           const std::set<std::string> &extensions)
  {
  #if defined(ANGLE_ENABLE_GL_DESKTOP_BACKEND)
      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("glTextureStorage2DMultisampleEXT", textureStorage2DMultisample);
          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);
          ASSIGN("glBlitFramebufferEXT", blitFramebufferEXT);
      }
  
      if (extensions.count("GL_EXT_framebuffer_multisample") != 0)
      {
          ASSIGN("glRenderbufferStorageMultisampleEXT", renderbufferStorageMultisample);
          ASSIGN("glRenderbufferStorageMultisampleEXT", renderbufferStorageMultisampleEXT);
      }
  
      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("glGetVertexAttribIivEXT", getVertexAttribIiv);
          ASSIGN("glGetVertexAttribIuivEXT", getVertexAttribIuiv);
          ASSIGN("glUniform1uiEXT", uniform1ui);
          ASSIGN("glUniform1uivEXT", uniform1uiv);
          ASSIGN("glUniform2uiEXT", uniform2ui);
          ASSIGN("glUniform2uivEXT", uniform2uiv);
          ASSIGN("glUniform3uiEXT", uniform3ui);
          ASSIGN("glUniform3uivEXT", uniform3uiv);
          ASSIGN("glUniform4uiEXT", uniform4ui);
          ASSIGN("glUniform4uivEXT", uniform4uiv);
          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_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);
          ASSIGN("glTexBufferEXT", texBufferEXT);
      }
  
      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);
      }
  
      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);
      }
  #endif  // defined(ANGLE_ENABLE_GL_DESKTOP_BACKEND)
  }
  
  void DispatchTableGL::initProcsGLES(const gl::Version &version,
                                      const std::set<std::string> &extensions)
  {
      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("glGetInteger64vEXT", getInteger64v);
          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("glFramebufferTexture2DMultisampleEXT", framebufferTexture2DMultisampleEXT);
          ASSIGN("glRenderbufferStorageMultisampleEXT", renderbufferStorageMultisample);
          ASSIGN("glRenderbufferStorageMultisampleEXT", renderbufferStorageMultisampleEXT);
      }
  
      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("glTexBufferEXT", texBufferEXT);
          ASSIGN("glTexBufferRangeEXT", texBufferRange);
          ASSIGN("glTexBufferRangeEXT", texBufferRangeEXT);
      }
  
      if (extensions.count("GL_EXT_texture_view") != 0)
      {
          ASSIGN("glTextureViewEXT", textureView);
      }
  
      if (extensions.count("GL_IMG_multisampled_render_to_texture") != 0)
      {
          ASSIGN("glFramebufferTexture2DMultisampleIMG", framebufferTexture2DMultisampleIMG);
          ASSIGN("glRenderbufferStorageMultisampleIMG", renderbufferStorageMultisampleIMG);
      }
  
      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_NV_framebuffer_blit") != 0)
      {
          ASSIGN("glBlitFramebufferNV", blitFramebufferNV);
      }
  
      if (extensions.count("GL_NV_polygon_mode") != 0)
      {
          ASSIGN("glPolygonModeNV", polygonModeNV);
      }
  
      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("glTexBufferOES", texBufferOES);
          ASSIGN("glTexBufferRangeOES", texBufferRange);
          ASSIGN("glTexBufferRangeOES", texBufferRangeOES);
      }
  
      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);
      }
  
      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);
      }
  }
  
  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_polygon_offset_clamp") != 0)
      {
          ASSIGN("glPolygonOffsetClampEXT", polygonOffsetClampEXT);
      }
  
      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("glProgramUniformMatrix4x2fvEXT", programUniformMatrix4x2fv);
          ASSIGN("glProgramUniformMatrix4x3fvEXT", programUniformMatrix4x3fv);
          ASSIGN("glUseProgramStagesEXT", useProgramStages);
          ASSIGN("glValidateProgramPipelineEXT", validateProgramPipeline);
      }
  
      if (extensions.count("GL_EXT_shader_framebuffer_fetch_non_coherent") != 0)
      {
          ASSIGN("glFramebufferFetchBarrierEXT", framebufferFetchBarrierEXT);
      }
  
      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_KHR_parallel_shader_compile") != 0)
      {
          ASSIGN("glMaxShaderCompilerThreadsKHR", maxShaderCompilerThreadsKHR);
      }
  
      if (extensions.count("GL_MESA_framebuffer_flip_y") != 0)
      {
          ASSIGN("glFramebufferParameteriMESA", framebufferParameteriMESA);
      }
  
      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_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 defined(ANGLE_ENABLE_GL_DESKTOP_BACKEND)
      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;
          textureStorage2DMultisample              = &glTextureStorage2DMultisampleNULL;
          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;
          blitFramebufferEXT = &glBlitFramebufferEXTNULL;
      }
  
      if (extensions.count("GL_EXT_framebuffer_multisample") != 0)
      {
          renderbufferStorageMultisample    = &glRenderbufferStorageMultisampleNULL;
          renderbufferStorageMultisampleEXT = &glRenderbufferStorageMultisampleEXTNULL;
      }
  
      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;
          getVertexAttribIiv   = &glGetVertexAttribIivNULL;
          getVertexAttribIuiv  = &glGetVertexAttribIuivNULL;
          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 (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;
          texBufferEXT = &glTexBufferEXTNULL;
      }
  
      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;
      }
  
      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;
      }
  #    endif  // defined(ANGLE_ENABLE_GL_DESKTOP_BACKEND)
  }
  
  void DispatchTableGL::initProcsGLESNULL(const gl::Version &version,
                                          const std::set<std::string> &extensions)
  {
      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;
          getInteger64v       = &glGetInteger64vNULL;
          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)
      {
          framebufferTexture2DMultisampleEXT = &glFramebufferTexture2DMultisampleEXTNULL;
          renderbufferStorageMultisample     = &glRenderbufferStorageMultisampleNULL;
          renderbufferStorageMultisampleEXT  = &glRenderbufferStorageMultisampleEXTNULL;
      }
  
      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;
          texBufferEXT      = &glTexBufferEXTNULL;
          texBufferRange    = &glTexBufferRangeNULL;
          texBufferRangeEXT = &glTexBufferRangeEXTNULL;
      }
  
      if (extensions.count("GL_EXT_texture_view") != 0)
      {
          textureView = &glTextureViewNULL;
      }
  
      if (extensions.count("GL_IMG_multisampled_render_to_texture") != 0)
      {
          framebufferTexture2DMultisampleIMG = &glFramebufferTexture2DMultisampleIMGNULL;
          renderbufferStorageMultisampleIMG  = &glRenderbufferStorageMultisampleIMGNULL;
      }
  
      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_framebuffer_blit") != 0)
      {
          blitFramebufferNV = &glBlitFramebufferNVNULL;
      }
  
      if (extensions.count("GL_NV_polygon_mode") != 0)
      {
          polygonModeNV = &glPolygonModeNVNULL;
      }
  
      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;
          texBufferOES      = &glTexBufferOESNULL;
          texBufferRange    = &glTexBufferRangeNULL;
          texBufferRangeOES = &glTexBufferRangeOESNULL;
      }
  
      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;
      }
  
      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;
      }
  }
  
  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_polygon_offset_clamp") != 0)
      {
          polygonOffsetClampEXT = &glPolygonOffsetClampEXTNULL;
      }
  
      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;
          programUniformMatrix4x2fv = &glProgramUniformMatrix4x2fvNULL;
          programUniformMatrix4x3fv = &glProgramUniformMatrix4x3fvNULL;
          useProgramStages          = &glUseProgramStagesNULL;
          validateProgramPipeline   = &glValidateProgramPipelineNULL;
      }
  
      if (extensions.count("GL_EXT_shader_framebuffer_fetch_non_coherent") != 0)
      {
          framebufferFetchBarrierEXT = &glFramebufferFetchBarrierEXTNULL;
      }
  
      if (extensions.count("GL_EXT_texture_storage") != 0)
      {
          texStorage1D     = &glTexStorage1DNULL;
          texStorage2D     = &glTexStorage2DNULL;
          texStorage3D     = &glTexStorage3DNULL;
          textureStorage1D = &glTextureStorage1DNULL;
          textureStorage2D = &glTextureStorage2DNULL;
          textureStorage3D = &glTextureStorage3DNULL;
      }
  
      if (extensions.count("GL_KHR_parallel_shader_compile") != 0)
      {
          maxShaderCompilerThreadsKHR = &glMaxShaderCompilerThreadsKHRNULL;
      }
  
      if (extensions.count("GL_MESA_framebuffer_flip_y") != 0)
      {
          framebufferParameteriMESA = &glFramebufferParameteriMESANULL;
      }
  
      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_OVR_multiview") != 0)
      {
          framebufferTextureMultiviewOVR = &glFramebufferTextureMultiviewOVRNULL;
      }
  }
  #endif  // defined(ANGLE_ENABLE_OPENGL_NULL)
  
  }  // namespace rx
  

Download