src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp - third_party/angle - Git at Google

 // 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"

 #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_blend_minmax") != 0)
     {
         ASSIGN("glBlendEquationEXT", blendEquation);
     }

     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("glProgramUniform1fEXT", programUniform1f);
         ASSIGN("glProgramUniform1fvEXT", programUniform1fv);
         ASSIGN("glProgramUniform1iEXT", programUniform1i);
         ASSIGN("glProgramUniform1ivEXT", programUniform1iv);
         ASSIGN("glProgramUniform1uiEXT", programUniform1ui);
         ASSIGN("glProgramUniform1uivEXT", programUniform1uiv);
         ASSIGN("glProgramUniform2dEXT", programUniform2d);
         ASSIGN("glProgramUniform2dvEXT", programUniform2dv);
         ASSIGN("glProgramUniform2fEXT", programUniform2f);
         ASSIGN("glProgramUniform2fvEXT", programUniform2fv);
         ASSIGN("glProgramUniform2iEXT", programUniform2i);
         ASSIGN("glProgramUniform2ivEXT", programUniform2iv);
         ASSIGN("glProgramUniform2uiEXT", programUniform2ui);
         ASSIGN("glProgramUniform2uivEXT", programUniform2uiv);
         ASSIGN("glProgramUniform3dEXT", programUniform3d);
         ASSIGN("glProgramUniform3dvEXT", programUniform3dv);
         ASSIGN("glProgramUniform3fEXT", programUniform3f);
         ASSIGN("glProgramUniform3fvEXT", programUniform3fv);
         ASSIGN("glProgramUniform3iEXT", programUniform3i);
         ASSIGN("glProgramUniform3ivEXT", programUniform3iv);
         ASSIGN("glProgramUniform3uiEXT", programUniform3ui);
         ASSIGN("glProgramUniform3uivEXT", programUniform3uiv);
         ASSIGN("glProgramUniform4dEXT", programUniform4d);
         ASSIGN("glProgramUniform4dvEXT", programUniform4dv);
         ASSIGN("glProgramUniform4fEXT", programUniform4f);
         ASSIGN("glProgramUniform4fvEXT", programUniform4fv);
         ASSIGN("glProgramUniform4iEXT", programUniform4i);
         ASSIGN("glProgramUniform4ivEXT", programUniform4iv);
         ASSIGN("glProgramUniform4uiEXT", programUniform4ui);
         ASSIGN("glProgramUniform4uivEXT", programUniform4uiv);
         ASSIGN("glProgramUniformMatrix2dvEXT", programUniformMatrix2dv);
         ASSIGN("glProgramUniformMatrix2fvEXT", programUniformMatrix2fv);
         ASSIGN("glProgramUniformMatrix2x3dvEXT", programUniformMatrix2x3dv);
         ASSIGN("glProgramUniformMatrix2x3fvEXT", programUniformMatrix2x3fv);
         ASSIGN("glProgramUniformMatrix2x4dvEXT", programUniformMatrix2x4dv);
         ASSIGN("glProgramUniformMatrix2x4fvEXT", programUniformMatrix2x4fv);
         ASSIGN("glProgramUniformMatrix3dvEXT", programUniformMatrix3dv);
         ASSIGN("glProgramUniformMatrix3fvEXT", programUniformMatrix3fv);
         ASSIGN("glProgramUniformMatrix3x2dvEXT", programUniformMatrix3x2dv);
         ASSIGN("glProgramUniformMatrix3x2fvEXT", programUniformMatrix3x2fv);
         ASSIGN("glProgramUniformMatrix3x4dvEXT", programUniformMatrix3x4dv);
         ASSIGN("glProgramUniformMatrix3x4fvEXT", programUniformMatrix3x4fv);
         ASSIGN("glProgramUniformMatrix4dvEXT", programUniformMatrix4dv);
         ASSIGN("glProgramUniformMatrix4fvEXT", programUniformMatrix4fv);
         ASSIGN("glProgramUniformMatrix4x2dvEXT", programUniformMatrix4x2dv);
         ASSIGN("glProgramUniformMatrix4x2fvEXT", programUniformMatrix4x2fv);
         ASSIGN("glProgramUniformMatrix4x3dvEXT", programUniformMatrix4x3dv);
         ASSIGN("glProgramUniformMatrix4x3fvEXT", programUniformMatrix4x3fv);
         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_geometry_shader4") != 0)
     {
         ASSIGN("glProgramParameteriEXT", programParameteri);
     }

     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_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_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_MESA_sampler_objects") != 0)
     {
         ASSIGN("glBindSampler", bindSampler);
         ASSIGN("glDeleteSamplers", deleteSamplers);
         ASSIGN("glGenSamplers", genSamplers);
         ASSIGN("glGetSamplerParameterfv", getSamplerParameterfv);
         ASSIGN("glGetSamplerParameteriv", getSamplerParameteriv);
         ASSIGN("glIsSampler", isSampler);
         ASSIGN("glSamplerParameterf", samplerParameterf);
         ASSIGN("glSamplerParameterfv", samplerParameterfv);
         ASSIGN("glSamplerParameteri", samplerParameteri);
         ASSIGN("glSamplerParameteriv", samplerParameteriv);
     }

     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_EGL_image_external") != 0)
     {
         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 (extensions.count("GL_QCOM_tiled_rendering") != 0)
     {
         ASSIGN("glEndTilingQCOM", endTilingQCOM);
         ASSIGN("glStartTilingQCOM", startTilingQCOM);
     }

     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_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_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_blend_equation_advanced") != 0)
     {
         ASSIGN("glBlendBarrierKHR", blendBarrier);
     }

     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);
         ASSIGN("glNamedFramebufferTextureMultiviewOVR", namedFramebufferTextureMultiviewOVR);
     }
 }

 }  // namespace rx