text: //
  // Autogenerated from gl.xml
  //
  // Mike Larson
  //
  // October 2021
  //
  
  #include <assert.h>
  
  #include "mgl.h"
  void mglActiveShaderProgram(GLMContext ctx, GLuint pipeline, GLuint program)
  {
          assert(0);
  }
  
  void mglBeginConditionalRender(GLMContext ctx, GLuint id, GLenum mode)
  {
          assert(0);
  }
  
  void mglBeginQuery(GLMContext ctx, GLenum target, GLuint id)
  {
          assert(0);
  }
  
  void mglBeginQueryIndexed(GLMContext ctx, GLenum target, GLuint index, GLuint id)
  {
          assert(0);
  }
  
  void mglBeginTransformFeedback(GLMContext ctx, GLenum primitiveMode)
  {
          assert(0);
  }
  
  void mglBindFragDataLocation(GLMContext ctx, GLuint program, GLuint color, const GLchar *name)
  {
          assert(0);
  }
  
  void mglBindFragDataLocationIndexed(GLMContext ctx, GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
  {
          assert(0);
  }
  
  void mglBindTransformFeedback(GLMContext ctx, GLenum target, GLuint id)
  {
          assert(0);
  }
  
  void mglClampColor(GLMContext ctx, GLenum target, GLenum clamp)
  {
          assert(0);
  }
  
  void mglClearBufferfi(GLMContext ctx, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
  {
          assert(0);
  }
  
  void mglClearBufferfv(GLMContext ctx, GLenum buffer, GLint drawbuffer, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglClearBufferiv(GLMContext ctx, GLenum buffer, GLint drawbuffer, const GLint *value)
  {
          assert(0);
  }
  
  void mglClearBufferuiv(GLMContext ctx, GLenum buffer, GLint drawbuffer, const GLuint *value)
  {
          assert(0);
  }
  
  void mglClipControl(GLMContext ctx, GLenum origin, GLenum depth)
  {
          assert(0);
  }
  
  void mglColorMaski(GLMContext ctx, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
  {
          assert(0);
  }
  
  void mglColorP3ui(GLMContext ctx, GLenum type, GLuint color)
  {
          assert(0);
  }
  
  void mglColorP3uiv(GLMContext ctx, GLenum type, const GLuint *color)
  {
          assert(0);
  }
  
  void mglColorP4ui(GLMContext ctx, GLenum type, GLuint color)
  {
          assert(0);
  }
  
  void mglColorP4uiv(GLMContext ctx, GLenum type, const GLuint *color)
  {
          assert(0);
  }
  
  void mglCopyImageSubData(GLMContext ctx, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
  {
          assert(0);
  }
  
  void mglCreateProgramPipelines(GLMContext ctx, GLsizei n, GLuint *pipelines)
  {
          assert(0);
  }
  
  void mglCreateQueries(GLMContext ctx, GLenum target, GLsizei n, GLuint *ids)
  {
          assert(0);
  }
  
  GLuint  mglCreateShaderProgramv(GLMContext ctx, GLenum type, GLsizei count, const GLchar *const*strings)
  {
          assert(0);
  }
  
  void mglCreateTransformFeedbacks(GLMContext ctx, GLsizei n, GLuint *ids)
  {
          assert(0);
  }
  
  void mglDebugMessageCallback(GLMContext ctx, GLDEBUGPROC callback, const void *userParam)
  {
          assert(0);
  }
  
  void mglDebugMessageControl(GLMContext ctx, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
  {
          assert(0);
  }
  
  void mglDebugMessageInsert(GLMContext ctx, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
  {
          assert(0);
  }
  
  void mglDeleteQueries(GLMContext ctx, GLsizei n, const GLuint *ids)
  {
          assert(0);
  }
  
  void mglDeleteTransformFeedbacks(GLMContext ctx, GLsizei n, const GLuint *ids)
  {
          assert(0);
  }
  
  void mglDepthRangeArrayv(GLMContext ctx, GLuint first, GLsizei count, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglDepthRangeIndexed(GLMContext ctx, GLuint index, GLdouble n, GLdouble f)
  {
          assert(0);
  }
  
  void mglDepthRangef(GLMContext ctx, GLfloat n, GLfloat f)
  {
          assert(0);
  }
  
  void mglDrawTransformFeedback(GLMContext ctx, GLenum mode, GLuint id)
  {
          assert(0);
  }
  
  void mglDrawTransformFeedbackInstanced(GLMContext ctx, GLenum mode, GLuint id, GLsizei instancecount)
  {
          assert(0);
  }
  
  void mglDrawTransformFeedbackStream(GLMContext ctx, GLenum mode, GLuint id, GLuint stream)
  {
          assert(0);
  }
  
  void mglDrawTransformFeedbackStreamInstanced(GLMContext ctx, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
  {
          assert(0);
  }
  
  void mglEndConditionalRender(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglEndQuery(GLMContext ctx, GLenum target)
  {
          assert(0);
  }
  
  void mglEndQueryIndexed(GLMContext ctx, GLenum target, GLuint index)
  {
          assert(0);
  }
  
  void mglEndTransformFeedback(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglGenQueries(GLMContext ctx, GLsizei n, GLuint *ids)
  {
          assert(0);
  }
  
  void mglGenTransformFeedbacks(GLMContext ctx, GLsizei n, GLuint *ids)
  {
          assert(0);
  }
  
  void mglGetActiveAtomicCounterBufferiv(GLMContext ctx, GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  void mglGetActiveSubroutineName(GLMContext ctx, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
  {
          assert(0);
  }
  
  void mglGetActiveSubroutineUniformName(GLMContext ctx, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
  {
          assert(0);
  }
  
  void mglGetActiveSubroutineUniformiv(GLMContext ctx, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
  {
          assert(0);
  }
  
  void mglGetBooleani_v(GLMContext ctx, GLenum target, GLuint index, GLboolean *data)
  {
          assert(0);
  }
  
  void mglGetBufferParameteri64v(GLMContext ctx, GLenum target, GLenum pname, GLint64 *params)
  {
          assert(0);
  }
  
  GLuint  mglGetDebugMessageLog(GLMContext ctx, GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
  {
          assert(0);
  }
  
  void mglGetDoublei_v(GLMContext ctx, GLenum target, GLuint index, GLdouble *data)
  {
          assert(0);
  }
  
  void mglGetFloati_v(GLMContext ctx, GLenum target, GLuint index, GLfloat *data)
  {
          assert(0);
  }
  
  GLint  mglGetFragDataIndex(GLMContext ctx, GLuint program, const GLchar *name)
  {
          assert(0);
  }
  
  GLint  mglGetFragDataLocation(GLMContext ctx, GLuint program, const GLchar *name)
  {
          assert(0);
  }
  
  GLenum  mglGetGraphicsResetStatus(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglGetMultisamplefv(GLMContext ctx, GLenum pname, GLuint index, GLfloat *val)
  {
          assert(0);
  }
  
  void mglGetObjectLabel(GLMContext ctx, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
  {
          assert(0);
  }
  
  void mglGetObjectPtrLabel(GLMContext ctx, const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
  {
          assert(0);
  }
  
  void mglGetProgramBinary(GLMContext ctx, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
  {
          assert(0);
  }
  
  void mglGetProgramInterfaceiv(GLMContext ctx, GLuint program, GLenum programInterface, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  void mglGetProgramPipelineInfoLog(GLMContext ctx, GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
  {
          assert(0);
  }
  
  void mglGetProgramPipelineiv(GLMContext ctx, GLuint pipeline, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  GLuint  mglGetProgramResourceIndex(GLMContext ctx, GLuint program, GLenum programInterface, const GLchar *name)
  {
          assert(0);
  }
  
  GLint  mglGetProgramResourceLocation(GLMContext ctx, GLuint program, GLenum programInterface, const GLchar *name)
  {
          assert(0);
  }
  
  GLint  mglGetProgramResourceLocationIndex(GLMContext ctx, GLuint program, GLenum programInterface, const GLchar *name)
  {
          assert(0);
  }
  
  void mglGetProgramResourceName(GLMContext ctx, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
  {
          assert(0);
  }
  
  void mglGetProgramResourceiv(GLMContext ctx, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei count, GLsizei *length, GLint *params)
  {
          assert(0);
  }
  
  void mglGetProgramStageiv(GLMContext ctx, GLuint program, GLenum shadertype, GLenum pname, GLint *values)
  {
          assert(0);
  }
  
  void mglGetQueryBufferObjecti64v(GLMContext ctx, GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
  {
          assert(0);
  }
  
  void mglGetQueryBufferObjectiv(GLMContext ctx, GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
  {
          assert(0);
  }
  
  void mglGetQueryBufferObjectui64v(GLMContext ctx, GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
  {
          assert(0);
  }
  
  void mglGetQueryBufferObjectuiv(GLMContext ctx, GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
  {
          assert(0);
  }
  
  void mglGetQueryIndexediv(GLMContext ctx, GLenum target, GLuint index, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  void mglGetQueryObjecti64v(GLMContext ctx, GLuint id, GLenum pname, GLint64 *params)
  {
          assert(0);
  }
  
  void mglGetQueryObjectiv(GLMContext ctx, GLuint id, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  void mglGetQueryObjectui64v(GLMContext ctx, GLuint id, GLenum pname, GLuint64 *params)
  {
          assert(0);
  }
  
  void mglGetQueryObjectuiv(GLMContext ctx, GLuint id, GLenum pname, GLuint *params)
  {
          assert(0);
  }
  
  void mglGetQueryiv(GLMContext ctx, GLenum target, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  void mglGetShaderPrecisionFormat(GLMContext ctx, GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
  {
          assert(0);
  }
  
  GLuint  mglGetSubroutineIndex(GLMContext ctx, GLuint program, GLenum shadertype, const GLchar *name)
  {
          assert(0);
  }
  
  GLint  mglGetSubroutineUniformLocation(GLMContext ctx, GLuint program, GLenum shadertype, const GLchar *name)
  {
          assert(0);
  }
  void mglGetTransformFeedbackVarying(GLMContext ctx, GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
  {
          assert(0);
  }
  
  void mglGetTransformFeedbacki64_v(GLMContext ctx, GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
  {
          assert(0);
  }
  
  void mglGetTransformFeedbacki_v(GLMContext ctx, GLuint xfb, GLenum pname, GLuint index, GLint *param)
  {
          assert(0);
  }
  
  void mglGetTransformFeedbackiv(GLMContext ctx, GLuint xfb, GLenum pname, GLint *param)
  {
          assert(0);
  }
  
  void mglGetUniformSubroutineuiv(GLMContext ctx, GLenum shadertype, GLint location, GLuint *params)
  {
          assert(0);
  }
  
  void mglGetUniformdv(GLMContext ctx, GLuint program, GLint location, GLdouble *params)
  {
          assert(0);
  }
  
  void mglGetUniformuiv(GLMContext ctx, GLuint program, GLint location, GLuint *params)
  {
          assert(0);
  }
  
  void mglGetVertexAttribIiv(GLMContext ctx, GLuint index, GLenum pname, GLint *params)
  {
          assert(0);
  }
  
  void mglGetVertexAttribIuiv(GLMContext ctx, GLuint index, GLenum pname, GLuint *params)
  {
          assert(0);
  }
  
  void mglGetVertexAttribLdv(GLMContext ctx, GLuint index, GLenum pname, GLdouble *params)
  {
          assert(0);
  }
  
  void mglGetnMapdv(GLMContext ctx, GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
  {
          assert(0);
  }
  
  void mglGetnMapfv(GLMContext ctx, GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
  {
          assert(0);
  }
  
  void mglGetnMapiv(GLMContext ctx, GLenum target, GLenum query, GLsizei bufSize, GLint *v)
  {
          assert(0);
  }
  
  void mglGetnPixelMapfv(GLMContext ctx, GLenum map, GLsizei bufSize, GLfloat *values)
  {
          assert(0);
  }
  
  void mglGetnPixelMapuiv(GLMContext ctx, GLenum map, GLsizei bufSize, GLuint *values)
  {
          assert(0);
  }
  
  void mglGetnPixelMapusv(GLMContext ctx, GLenum map, GLsizei bufSize, GLushort *values)
  {
          assert(0);
  }
  
  void mglGetnTexImage(GLMContext ctx, GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
  {
          assert(0);
  }
  
  void mglGetnUniformdv(GLMContext ctx, GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
  {
          assert(0);
  }
  
  void mglGetnUniformfv(GLMContext ctx, GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
  {
          assert(0);
  }
  
  void mglGetnUniformiv(GLMContext ctx, GLuint program, GLint location, GLsizei bufSize, GLint *params)
  {
          assert(0);
  }
  
  void mglGetnUniformuiv(GLMContext ctx, GLuint program, GLint location, GLsizei bufSize, GLuint *params)
  {
          assert(0);
  }
  
  GLboolean mglIsQuery(GLMContext ctx, GLuint id)
  {
          assert(0);
  }
  
  GLboolean mglIsTransformFeedback(GLMContext ctx, GLuint id)
  {
          assert(0);
  }
  
  void mglMinSampleShading(GLMContext ctx, GLfloat value)
  {
          assert(0);
  }
  
  void mglMultiDrawArraysIndirectCount(GLMContext ctx, GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
  {
          assert(0);
  }
  
  void mglMultiDrawElementsIndirectCount(GLMContext ctx, GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
  {
          assert(0);
  }
  
  void mglNormalP3ui(GLMContext ctx, GLenum type, GLuint coords)
  {
          assert(0);
  }
  
  void mglNormalP3uiv(GLMContext ctx, GLenum type, const GLuint *coords)
  {
          assert(0);
  }
  
  void mglObjectLabel(GLMContext ctx, GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
  {
          assert(0);
  }
  
  void mglObjectPtrLabel(GLMContext ctx, const void *ptr, GLsizei length, const GLchar *label)
  {
          assert(0);
  }
  
  void mglPatchParameterfv(GLMContext ctx, GLenum pname, const GLfloat *values)
  {
          assert(0);
  }
  
  void mglPatchParameteri(GLMContext ctx, GLenum pname, GLint value)
  {
          assert(0);
  }
  
  void mglPauseTransformFeedback(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglPolygonOffsetClamp(GLMContext ctx, GLfloat factor, GLfloat units, GLfloat clamp)
  {
          assert(0);
  }
  
  void mglPopDebugGroup(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglPrimitiveRestartIndex(GLMContext ctx, GLuint index)
  {
          assert(0);
  }
  
  void mglProgramBinary(GLMContext ctx, GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
  {
          assert(0);
  }
  
  void mglProgramParameteri(GLMContext ctx, GLuint program, GLenum pname, GLint value)
  {
          assert(0);
  }
  
  void mglProgramUniform1d(GLMContext ctx, GLuint program, GLint location, GLdouble v0)
  {
          assert(0);
  }
  
  void mglProgramUniform1dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniform1f(GLMContext ctx, GLuint program, GLint location, GLfloat v0)
  {
          assert(0);
  }
  
  void mglProgramUniform1fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniform1i(GLMContext ctx, GLuint program, GLint location, GLint v0)
  {
          assert(0);
  }
  
  void mglProgramUniform1iv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform1ui(GLMContext ctx, GLuint program, GLint location, GLuint v0)
  {
          assert(0);
  }
  
  void mglProgramUniform1uiv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform2d(GLMContext ctx, GLuint program, GLint location, GLdouble v0, GLdouble v1)
  {
          assert(0);
  }
  
  void mglProgramUniform2dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniform2f(GLMContext ctx, GLuint program, GLint location, GLfloat v0, GLfloat v1)
  {
          assert(0);
  }
  
  void mglProgramUniform2fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniform2i(GLMContext ctx, GLuint program, GLint location, GLint v0, GLint v1)
  {
          assert(0);
  }
  
  void mglProgramUniform2iv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform2ui(GLMContext ctx, GLuint program, GLint location, GLuint v0, GLuint v1)
  {
          assert(0);
  }
  
  void mglProgramUniform2uiv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform3d(GLMContext ctx, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
  {
          assert(0);
  }
  
  void mglProgramUniform3dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniform3f(GLMContext ctx, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
  {
          assert(0);
  }
  
  void mglProgramUniform3fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniform3i(GLMContext ctx, GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
  {
          assert(0);
  }
  
  void mglProgramUniform3iv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform3ui(GLMContext ctx, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
  {
          assert(0);
  }
  
  void mglProgramUniform3uiv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform4d(GLMContext ctx, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
  {
          assert(0);
  }
  
  void mglProgramUniform4dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniform4f(GLMContext ctx, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
  {
          assert(0);
  }
  
  void mglProgramUniform4fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniform4i(GLMContext ctx, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
  {
          assert(0);
  }
  
  void mglProgramUniform4iv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglProgramUniform4ui(GLMContext ctx, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
  {
          assert(0);
  }
  
  void mglProgramUniform4uiv(GLMContext ctx, GLuint program, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix2dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix2fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix2x3dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix2x3fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix2x4dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix2x4fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix3dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix3fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix3x2dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix3x2fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix3x4dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix3x4fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix4dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix4fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix4x2dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix4x2fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix4x3dv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglProgramUniformMatrix4x3fv(GLMContext ctx, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglProvokingVertex(GLMContext ctx, GLenum mode)
  {
          assert(0);
  }
  
  void mglPushDebugGroup(GLMContext ctx, GLenum source, GLuint id, GLsizei length, const GLchar *message)
  {
          assert(0);
  }
  
  void mglQueryCounter(GLMContext ctx, GLuint id, GLenum target)
  {
          assert(0);
  }
  
  void mglReadnPixels(GLMContext ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
  {
          assert(0);
  }
  
  void mglReleaseShaderCompiler(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglResumeTransformFeedback(GLMContext ctx)
  {
          assert(0);
  }
  
  void mglSampleMaski(GLMContext ctx, GLuint maskNumber, GLbitfield mask)
  {
          assert(0);
  }
  
  void mglScissorArrayv(GLMContext ctx, GLuint first, GLsizei count, const GLint *v)
  {
          assert(0);
  }
  
  void mglScissorIndexed(GLMContext ctx, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
  {
          assert(0);
  }
  
  void mglScissorIndexedv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglSecondaryColorP3ui(GLMContext ctx, GLenum type, GLuint color)
  {
          assert(0);
  }
  
  void mglSecondaryColorP3uiv(GLMContext ctx, GLenum type, const GLuint *color)
  {
          assert(0);
  }
  
  void mglShaderBinary(GLMContext ctx, GLsizei count, const GLuint *shaders, GLenum binaryFormat, const void *binary, GLsizei length)
  {
          assert(0);
  }
  
  void mglShaderStorageBlockBinding(GLMContext ctx, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
  {
          assert(0);
  }
  
  void mglSpecializeShader(GLMContext ctx, GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue)
  {
          assert(0);
  }
  
  void mglTexBuffer(GLMContext ctx, GLenum target, GLenum internalformat, GLuint buffer)
  {
          assert(0);
  }
  
  void mglTexBufferRange(GLMContext ctx, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
  {
          assert(0);
  }
  
  void mglTexStorage2DMultisample(GLMContext ctx, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
  {
          assert(0);
  }
  
  void mglTexStorage3DMultisample(GLMContext ctx, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
  {
          assert(0);
  }
  
  void mglTransformFeedbackBufferBase(GLMContext ctx, GLuint xfb, GLuint index, GLuint buffer)
  {
          assert(0);
  }
  
  void mglTransformFeedbackBufferRange(GLMContext ctx, GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
  {
          assert(0);
  }
  
  void mglTransformFeedbackVaryings(GLMContext ctx, GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)
  {
          assert(0);
  }
  
  void mglUniform1d(GLMContext ctx, GLint location, GLdouble x)
  {
          assert(0);
  }
  
  void mglUniform1dv(GLMContext ctx, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniform1f(GLMContext ctx, GLint location, GLfloat v0)
  {
          assert(0);
  }
  
  void mglUniform1fv(GLMContext ctx, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniform1i(GLMContext ctx, GLint location, GLint v0)
  {
          assert(0);
  }
  
  void mglUniform1iv(GLMContext ctx, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglUniform1ui(GLMContext ctx, GLint location, GLuint v0)
  {
          assert(0);
  }
  
  void mglUniform1uiv(GLMContext ctx, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglUniform2d(GLMContext ctx, GLint location, GLdouble x, GLdouble y)
  {
          assert(0);
  }
  
  void mglUniform2dv(GLMContext ctx, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniform2f(GLMContext ctx, GLint location, GLfloat v0, GLfloat v1)
  {
          assert(0);
  }
  
  void mglUniform2fv(GLMContext ctx, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniform2i(GLMContext ctx, GLint location, GLint v0, GLint v1)
  {
          assert(0);
  }
  
  void mglUniform2iv(GLMContext ctx, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglUniform2ui(GLMContext ctx, GLint location, GLuint v0, GLuint v1)
  {
          assert(0);
  }
  
  void mglUniform2uiv(GLMContext ctx, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglUniform3d(GLMContext ctx, GLint location, GLdouble x, GLdouble y, GLdouble z)
  {
          assert(0);
  }
  
  void mglUniform3dv(GLMContext ctx, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniform3f(GLMContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
  {
          assert(0);
  }
  
  void mglUniform3fv(GLMContext ctx, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniform3i(GLMContext ctx, GLint location, GLint v0, GLint v1, GLint v2)
  {
          assert(0);
  }
  
  void mglUniform3iv(GLMContext ctx, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglUniform3ui(GLMContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2)
  {
          assert(0);
  }
  
  void mglUniform3uiv(GLMContext ctx, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglUniform4d(GLMContext ctx, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
          assert(0);
  }
  
  void mglUniform4dv(GLMContext ctx, GLint location, GLsizei count, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniform4f(GLMContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
  {
          assert(0);
  }
  
  void mglUniform4fv(GLMContext ctx, GLint location, GLsizei count, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniform4i(GLMContext ctx, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
  {
          assert(0);
  }
  
  void mglUniform4iv(GLMContext ctx, GLint location, GLsizei count, const GLint *value)
  {
          assert(0);
  }
  
  void mglUniform4ui(GLMContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
  {
          assert(0);
  }
  
  void mglUniform4uiv(GLMContext ctx, GLint location, GLsizei count, const GLuint *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix2dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix2fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix2x3dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix2x3fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix2x4dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix2x4fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix3dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix3fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix3x2dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix3x2fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix3x4dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix3x4fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix4dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix4fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix4x2dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix4x2fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix4x3dv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
  {
          assert(0);
  }
  
  void mglUniformMatrix4x3fv(GLMContext ctx, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
  {
          assert(0);
  }
  
  void mglUniformSubroutinesuiv(GLMContext ctx, GLenum shadertype, GLsizei count, const GLuint *indices)
  {
          assert(0);
  }
  
  void mglValidateProgram(GLMContext ctx, GLuint program)
  {
          assert(0);
  }
  
  void mglValidateProgramPipeline(GLMContext ctx, GLuint pipeline)
  {
          assert(0);
  }
  
  void mglVertexAttrib1d(GLMContext ctx, GLuint index, GLdouble x)
  {
          assert(0);
  }
  
  void mglVertexAttrib1dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib1f(GLMContext ctx, GLuint index, GLfloat x)
  {
          assert(0);
  }
  
  void mglVertexAttrib1fv(GLMContext ctx, GLuint index, const GLfloat *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib1s(GLMContext ctx, GLuint index, GLshort x)
  {
          assert(0);
  }
  
  void mglVertexAttrib1sv(GLMContext ctx, GLuint index, const GLshort *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib2d(GLMContext ctx, GLuint index, GLdouble x, GLdouble y)
  {
          assert(0);
  }
  
  void mglVertexAttrib2dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib2f(GLMContext ctx, GLuint index, GLfloat x, GLfloat y)
  {
          assert(0);
  }
  
  void mglVertexAttrib2fv(GLMContext ctx, GLuint index, const GLfloat *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib2s(GLMContext ctx, GLuint index, GLshort x, GLshort y)
  {
          assert(0);
  }
  
  void mglVertexAttrib2sv(GLMContext ctx, GLuint index, const GLshort *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib3d(GLMContext ctx, GLuint index, GLdouble x, GLdouble y, GLdouble z)
  {
          assert(0);
  }
  
  void mglVertexAttrib3dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib3f(GLMContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z)
  {
          assert(0);
  }
  
  void mglVertexAttrib3fv(GLMContext ctx, GLuint index, const GLfloat *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib3s(GLMContext ctx, GLuint index, GLshort x, GLshort y, GLshort z)
  {
          assert(0);
  }
  
  void mglVertexAttrib3sv(GLMContext ctx, GLuint index, const GLshort *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Nbv(GLMContext ctx, GLuint index, const GLbyte *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Niv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Nsv(GLMContext ctx, GLuint index, const GLshort *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Nub(GLMContext ctx, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Nubv(GLMContext ctx, GLuint index, const GLubyte *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Nuiv(GLMContext ctx, GLuint index, const GLuint *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4Nusv(GLMContext ctx, GLuint index, const GLushort *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4bv(GLMContext ctx, GLuint index, const GLbyte *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4d(GLMContext ctx, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
          assert(0);
  }
  
  void mglVertexAttrib4dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4f(GLMContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
  {
          assert(0);
  }
  
  void mglVertexAttrib4fv(GLMContext ctx, GLuint index, const GLfloat *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4iv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4s(GLMContext ctx, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
  {
          assert(0);
  }
  
  void mglVertexAttrib4sv(GLMContext ctx, GLuint index, const GLshort *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4ubv(GLMContext ctx, GLuint index, const GLubyte *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4uiv(GLMContext ctx, GLuint index, const GLuint *v)
  {
          assert(0);
  }
  
  void mglVertexAttrib4usv(GLMContext ctx, GLuint index, const GLushort *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI1i(GLMContext ctx, GLuint index, GLint x)
  {
          assert(0);
  }
  
  void mglVertexAttribI1iv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI1ui(GLMContext ctx, GLuint index, GLuint x)
  {
          assert(0);
  }
  
  void mglVertexAttribI1uiv(GLMContext ctx, GLuint index, const GLuint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI2i(GLMContext ctx, GLuint index, GLint x, GLint y)
  {
          assert(0);
  }
  
  void mglVertexAttribI2iv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI2ui(GLMContext ctx, GLuint index, GLuint x, GLuint y)
  {
          assert(0);
  }
  
  void mglVertexAttribI2uiv(GLMContext ctx, GLuint index, const GLuint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI3i(GLMContext ctx, GLuint index, GLint x, GLint y, GLint z)
  {
          assert(0);
  }
  
  void mglVertexAttribI3iv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI3ui(GLMContext ctx, GLuint index, GLuint x, GLuint y, GLuint z)
  {
          assert(0);
  }
  
  void mglVertexAttribI3uiv(GLMContext ctx, GLuint index, const GLuint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI4bv(GLMContext ctx, GLuint index, const GLbyte *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI4i(GLMContext ctx, GLuint index, GLint x, GLint y, GLint z, GLint w)
  {
          assert(0);
  }
  
  void mglVertexAttribI4iv(GLMContext ctx, GLuint index, const GLint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI4sv(GLMContext ctx, GLuint index, const GLshort *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI4ubv(GLMContext ctx, GLuint index, const GLubyte *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI4ui(GLMContext ctx, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
  {
          assert(0);
  }
  
  void mglVertexAttribI4uiv(GLMContext ctx, GLuint index, const GLuint *v)
  {
          assert(0);
  }
  
  void mglVertexAttribI4usv(GLMContext ctx, GLuint index, const GLushort *v)
  {
          assert(0);
  }
  
  void mglVertexAttribL1d(GLMContext ctx, GLuint index, GLdouble x)
  {
          assert(0);
  }
  
  void mglVertexAttribL1dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttribL2d(GLMContext ctx, GLuint index, GLdouble x, GLdouble y)
  {
          assert(0);
  }
  
  void mglVertexAttribL2dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttribL3d(GLMContext ctx, GLuint index, GLdouble x, GLdouble y, GLdouble z)
  {
          assert(0);
  }
  
  void mglVertexAttribL3dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttribL4d(GLMContext ctx, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
  {
          assert(0);
  }
  
  void mglVertexAttribL4dv(GLMContext ctx, GLuint index, const GLdouble *v)
  {
          assert(0);
  }
  
  void mglVertexAttribP1ui(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexAttribP1uiv(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
  {
          assert(0);
  }
  
  void mglVertexAttribP2ui(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexAttribP2uiv(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
  {
          assert(0);
  }
  
  void mglVertexAttribP3ui(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexAttribP3uiv(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
  {
          assert(0);
  }
  
  void mglVertexAttribP4ui(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexAttribP4uiv(GLMContext ctx, GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
  {
          assert(0);
  }
  
  void mglVertexP2ui(GLMContext ctx, GLenum type, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexP2uiv(GLMContext ctx, GLenum type, const GLuint *value)
  {
          assert(0);
  }
  
  void mglVertexP3ui(GLMContext ctx, GLenum type, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexP3uiv(GLMContext ctx, GLenum type, const GLuint *value)
  {
          assert(0);
  }
  
  void mglVertexP4ui(GLMContext ctx, GLenum type, GLuint value)
  {
          assert(0);
  }
  
  void mglVertexP4uiv(GLMContext ctx, GLenum type, const GLuint *value)
  {
          assert(0);
  }
  
  void mglViewportArrayv(GLMContext ctx, GLuint first, GLsizei count, const GLfloat *v)
  {
          assert(0);
  }
  
  void mglViewportIndexedf(GLMContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
  {
          assert(0);
  }
  
  void mglViewportIndexedfv(GLMContext ctx, GLuint index, const GLfloat *v)
  {
          assert(0);
  }
  
  